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 vm2 part: beginning. */
6 #line 163 "../../libpoke/pvm.jitter"
7 #line 163 "../../libpoke/pvm.jitter"
8 
9 #   include <config.h>
10 
11 /* User-specified code, initial vm2 part: end */
12 
13 /* These two macros are convenient for making VM-specific identifiers
14    using VM-independent macros from a public header, without polluting
15    the global namespace. */
16 #define JITTER_VM_PREFIX_LOWER_CASE pvm
17 #define JITTER_VM_PREFIX_UPPER_CASE PVM
18 
19 //#include <config.h>
20 
21 #include <stdbool.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 
25 /* Early C code from the user. */
26 #line 169 "../../libpoke/pvm.jitter"
27 #line 169 "../../libpoke/pvm.jitter"
28 
29 #   include <config.h>
30 #   include <stdlib.h>
31 #   include <string.h>
32 #   include <assert.h>
33 #   include "xalloc.h"
34 #   include "timespec.h"
35 #   include "intprops.h"
36 
37 #   include "pvm-alloc.h"
38   /* End of the early C code from the user. */
39 
40 #include <jitter/jitter.h>
41 #include <jitter/jitter-instruction.h>
42 
43 #define JITTER_THIS_CAN_INCLUDE_JITTER_EXECUTOR_H
44 #include <jitter/jitter-executor.h>
45 
46 #ifdef JITTER_ENABLE_ASSEMBLY
47 #include <jitter/jitter-machine-common.h>
48 #include <jitter/machine/jitter-machine.h>
49 #endif // #ifdef JITTER_ENABLE_ASSEMBLY
50 #include <jitter/jitter-fatal.h>
51 #include <jitter/jitter-malloc.h>
52 
53 #include "pvm-vm.h"
54 //#include "pvm-meta-instructions.h"
55 //#include "pvm-specialized-instructions.h"
56 //#include "pvm-state.h"
57 
58 /* Include stack data structure support. */
59 #include <jitter/jitter-stack.h>
60 
61 /* Include patch-in definitions, only if patch-in is enabled.  We knoe whether it is
62    by checking JITTER_HAVE_PATCH_IN , defined in jitter/jitter-patch-in.h . */
63 #include <jitter/jitter-patch-in.h>
64 #ifdef JITTER_HAVE_PATCH_IN
65 # include <jitter/jitter-fast-branch.h>
66 
67   JITTER_DEFECT_DESCRIPTOR_DECLARATIONS_(pvm);
68   JITTER_PATCH_IN_DESCRIPTOR_DECLARATIONS_(pvm);
69 #endif // #ifdef JITTER_HAVE_PATCH_IN
70 
71 /* Always include fast-branch definitions, which use patch-ins where possible
72    or consist in fallback definitions otherwise. */
73 #include <jitter/jitter-fast-branch.h>
74 
75 #define JITTER_FAST_BRANCH_PREFIX pvm_
76 
77 /* Most of the needed macros are in jitter-executor.h .  This however
78    needs to be here, as it relies on a prefix to be substituted. */
79 #define JITTER_STATE_BACKING  \
80   (jitter_original_state->pvm_state_backing)
81 /* Expand to an l-value evaluating to the pending_notification field for
82    the current state. */
83 #define JITTER_PENDING_NOTIFICATIONS  \
84   (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA->pending_notifications)
85 /* Expand to an l-value evaluating to the pending field of the struct
86    jitter_signal_notification element for the given signal, for the
87    current state. */
88 #define JITTER_PENDING_SIGNAL_NOTIFICATION(signal_id)  \
89   ((PVM_OWN_SPECIAL_PURPOSE_STATE_DATA->pending_signal_notifications + (signal_id))->pending)
90 
91 /* Expand to the i-th fast register as an lvalue.  This is used internally,
92    always with a literal index . */
93 #define JITTER_FAST_REGISTER(class, index)                             \
94   (JITTER_CONCATENATE_FOUR(jitter_state_runtime.jitter_fast_register_, \
95                            class, _, index))
96 
97 /* Expand to a slow register lvalue, given an offset in bytes from the base. */
98 #define JITTER_SLOW_REGISTER_FROM_OFFSET(c, offset)               \
99   (* ((JITTER_CONCATENATE_TWO(pvm_register_, c) * restrict)  \
100       (((char *) jitter_array_base) + offset)))
101 
102 /* Expand to the i-th register, which must be a slow register, as an lvalue.
103    The given index must be a register index counting from 0 and including fast
104    regusters as well, if there are any.  For example if an r class had 3 fast
105    registers then the first slow register would be %r3, to be accessed as
106    JITTER_SLOW_REGISTER(r, 3).  It would be invalid to access %r0, %r1 and
107    %r2 which this macro, as %r0, %r1 and %r2 would be fast. */
108 #define JITTER_SLOW_REGISTER(c, i)                                          \
109   JITTER_SLOW_REGISTER_FROM_OFFSET(c, PVM_SLOW_REGISTER_OFFSET(c, i))
110 
111 /* It's not possible to have a single macro JITTER_REGISTER taking an index and
112    expanding to either a fast or a slow register lvalue, due to CPP conditional
113    limitations.  This restriction is unfortunate, but we have to live with it
114    as long as we don't switch to a different preprocessor.
115    What we can have is a set of zero-argument macros each expanding to a register
116    lvalue, for *a limited number* of registers.  Here we define access macros for
117    every fast register plus a reasonable number (currently 32) of slow registers,
118    per class. */
119 #define JITTER_REGISTER_r_0    JITTER_SLOW_REGISTER(r, 0)
120 #define JITTER_REGISTER_r_1    JITTER_SLOW_REGISTER(r, 1)
121 #define JITTER_REGISTER_r_2    JITTER_SLOW_REGISTER(r, 2)
122 #define JITTER_REGISTER_r_3    JITTER_SLOW_REGISTER(r, 3)
123 #define JITTER_REGISTER_r_4    JITTER_SLOW_REGISTER(r, 4)
124 #define JITTER_REGISTER_r_5    JITTER_SLOW_REGISTER(r, 5)
125 #define JITTER_REGISTER_r_6    JITTER_SLOW_REGISTER(r, 6)
126 #define JITTER_REGISTER_r_7    JITTER_SLOW_REGISTER(r, 7)
127 #define JITTER_REGISTER_r_8    JITTER_SLOW_REGISTER(r, 8)
128 #define JITTER_REGISTER_r_9    JITTER_SLOW_REGISTER(r, 9)
129 #define JITTER_REGISTER_r_10   JITTER_SLOW_REGISTER(r, 10)
130 #define JITTER_REGISTER_r_11   JITTER_SLOW_REGISTER(r, 11)
131 #define JITTER_REGISTER_r_12   JITTER_SLOW_REGISTER(r, 12)
132 #define JITTER_REGISTER_r_13   JITTER_SLOW_REGISTER(r, 13)
133 #define JITTER_REGISTER_r_14   JITTER_SLOW_REGISTER(r, 14)
134 #define JITTER_REGISTER_r_15   JITTER_SLOW_REGISTER(r, 15)
135 #define JITTER_REGISTER_r_16   JITTER_SLOW_REGISTER(r, 16)
136 #define JITTER_REGISTER_r_17   JITTER_SLOW_REGISTER(r, 17)
137 #define JITTER_REGISTER_r_18   JITTER_SLOW_REGISTER(r, 18)
138 #define JITTER_REGISTER_r_19   JITTER_SLOW_REGISTER(r, 19)
139 #define JITTER_REGISTER_r_20   JITTER_SLOW_REGISTER(r, 20)
140 #define JITTER_REGISTER_r_21   JITTER_SLOW_REGISTER(r, 21)
141 #define JITTER_REGISTER_r_22   JITTER_SLOW_REGISTER(r, 22)
142 #define JITTER_REGISTER_r_23   JITTER_SLOW_REGISTER(r, 23)
143 #define JITTER_REGISTER_r_24   JITTER_SLOW_REGISTER(r, 24)
144 #define JITTER_REGISTER_r_25   JITTER_SLOW_REGISTER(r, 25)
145 #define JITTER_REGISTER_r_26   JITTER_SLOW_REGISTER(r, 26)
146 #define JITTER_REGISTER_r_27   JITTER_SLOW_REGISTER(r, 27)
147 #define JITTER_REGISTER_r_28   JITTER_SLOW_REGISTER(r, 28)
148 #define JITTER_REGISTER_r_29   JITTER_SLOW_REGISTER(r, 29)
149 #define JITTER_REGISTER_r_30   JITTER_SLOW_REGISTER(r, 30)
150 #define JITTER_REGISTER_r_31   JITTER_SLOW_REGISTER(r, 31)
151 
152 
153 #ifdef JITTER_DISPATCH_NO_THREADING
154 
155 /* Reserve the scratch register, if any. */
156 #ifdef JITTER_SCRATCH_REGISTER
157   register union jitter_word
158   jitter_residual_argument_scratch_register_variable asm (JITTER_STRINGIFY(JITTER_SCRATCH_REGISTER));
159 #endif // #ifdef JITTER_SCRATCH_REGISTER
160 
161 /* Reserve The Array base register. */
162 #ifndef JITTER_BASE_REGISTER
163 # error "the machine does not define JITTER_BASE_REGISTER"
164 #else
165 register char * restrict
166 pvm_array_base_register_variable asm (JITTER_STRINGIFY(JITTER_BASE_REGISTER));
167 #endif // #ifndef JITTER_BASE_REGISTER
168 
169 /* Reserve registers for our 3 residual arguments.  If this particular VM doesn't
170    need all of those supported by the assembly machine then reserve only the first
171    ones.  If, on the other hand, we need more residual arguments than we have
172    available registers, use CPP macros to map the remaining residual arguments
173    to memory locations relative to the base, with constant offsets. */
174 
175 /* Define a macro for the 0-th residual as a register, or as a residual
176    memory slot.  Also define a macro expanding to inline asm code with
177    output constraints on the appropriate register or memory, to let GCC
178    know that its value has been changed by unknown code. */
179 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
180   register union jitter_word
181   jitter_residual_argument_0_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_0));
182 # define JITTER_RESIDUAL_ARGUMENT_0               \
183     jitter_residual_argument_0_register_variable
184 # define JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY                 \
185     JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_0_register_variable)
186 #else
187 # define JITTER_RESIDUAL_ARGUMENT_0  \
188     (* (union jitter_word *)                 \
189        (jitter_array_base + PVM_RESIDUAL_OFFSET(0)))
190 # define JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY                    \
191     JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_0)
192 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
193 
194 /* Define a macro for the 1-th residual as a register, or as a residual
195    memory slot.  Also define a macro expanding to inline asm code with
196    output constraints on the appropriate register or memory, to let GCC
197    know that its value has been changed by unknown code. */
198 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
199   register union jitter_word
200   jitter_residual_argument_1_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_1));
201 # define JITTER_RESIDUAL_ARGUMENT_1               \
202     jitter_residual_argument_1_register_variable
203 # define JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY                 \
204     JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_1_register_variable)
205 #else
206 # define JITTER_RESIDUAL_ARGUMENT_1  \
207     (* (union jitter_word *)                 \
208        (jitter_array_base + PVM_RESIDUAL_OFFSET(1)))
209 # define JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY                    \
210     JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_1)
211 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
212 
213 /* Define a macro for the 2-th residual as a register, or as a residual
214    memory slot.  Also define a macro expanding to inline asm code with
215    output constraints on the appropriate register or memory, to let GCC
216    know that its value has been changed by unknown code. */
217 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
218   register union jitter_word
219   jitter_residual_argument_2_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_2));
220 # define JITTER_RESIDUAL_ARGUMENT_2               \
221     jitter_residual_argument_2_register_variable
222 # define JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY                 \
223     JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_2_register_variable)
224 #else
225 # define JITTER_RESIDUAL_ARGUMENT_2  \
226     (* (union jitter_word *)                 \
227        (jitter_array_base + PVM_RESIDUAL_OFFSET(2)))
228 # define JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY                    \
229     JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_2)
230 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
231 
232 /* The global register values we reserve in this compilation unit are
233    callee-save: the called function is supposed to save them before
234    setting them, and restore them to their previous value before
235    returning to the caller.  Of course this is not done automatically
236    in this compilation unit, so we have to do it by hand.  Notice that
237    every variable allocated to a register by GCC will not use the
238    registers we reserved, so we can be sure that, if we save our
239    global register variables before setting them for the first time,
240    their values will be the ones we want to retain. */
241 
242 /* The buffer where I keep the original register values needs to hold
243    every residual register, plus possibly the scratch register and the
244    residual base; those two registers are not always used, but allocating
245    just two words more costs essentially nothing and lets me simplify
246    the code a little.  The two words are not written or read unless
247    needed. */
248 #define PVM_REGISTER_BUFFER_ELEMENT_NO (JITTER_RESIDUAL_REGISTER_NO + 2)
249 __attribute__ ((noinline, cold))
250 
251 static void
pvm_save_registers(union jitter_word * buffer)252 pvm_save_registers (union jitter_word *buffer)
253 {
254   buffer [0].pointer = (union jitter_word*) pvm_array_base_register_variable;
255 #ifdef JITTER_SCRATCH_REGISTER
256   buffer [1] = jitter_residual_argument_scratch_register_variable;
257 #endif // #ifdef JITTER_SCRATCH_REGISTER
258 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
259   buffer [0 + 2] = JITTER_RESIDUAL_ARGUMENT_0;
260 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
261 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
262   buffer [1 + 2] = JITTER_RESIDUAL_ARGUMENT_1;
263 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
264 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
265   buffer [2 + 2] = JITTER_RESIDUAL_ARGUMENT_2;
266 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
267 }
268 
269 __attribute__ ((noinline, cold))
270 static void
pvm_restore_registers(const union jitter_word * buffer)271 pvm_restore_registers (const union jitter_word *buffer)
272 {
273   pvm_array_base_register_variable = (char *) buffer [0].pointer;
274 #ifdef JITTER_SCRATCH_REGISTER
275   jitter_residual_argument_scratch_register_variable = buffer [1];
276 #endif // #ifdef JITTER_SCRATCH_REGISTER
277 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
278   JITTER_RESIDUAL_ARGUMENT_0 = buffer [0 + 2];
279 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
280 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
281   JITTER_RESIDUAL_ARGUMENT_1 = buffer [1 + 2];
282 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
283 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
284   JITTER_RESIDUAL_ARGUMENT_2 = buffer [2 + 2];
285 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
286 }
287 
288 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
289 
290 
291 /* Wrapper definition of the top operation for the TOS-optimized stack "stack". */
292 #define JITTER_TOP_STACK()  \
293   JITTER_STACK_TOS_TOP(pvm_val, jitter_state_runtime. , stack)
294 
295 /* Wrapper definition of the under_top operation for the TOS-optimized stack "stack". */
296 #define JITTER_UNDER_TOP_STACK()  \
297   JITTER_STACK_TOS_UNDER_TOP(pvm_val, jitter_state_runtime. , stack)
298 
299 /* Wrapper definition of the at_depth operation for the TOS-optimized stack "stack". */
300 #define JITTER_AT_DEPTH_STACK(x0)  \
301   JITTER_STACK_TOS_AT_DEPTH(pvm_val, jitter_state_runtime. , stack, x0)
302 
303 /* Wrapper definition of the at_nonzero_depth operation for the TOS-optimized stack "stack". */
304 #define JITTER_AT_NONZERO_DEPTH_STACK(x0)  \
305   JITTER_STACK_TOS_AT_NONZERO_DEPTH(pvm_val, jitter_state_runtime. , stack, x0)
306 
307 /* Wrapper definition of the set_at_depth operation for the TOS-optimized stack "stack". */
308 #define JITTER_SET_AT_DEPTH_STACK(x0, x1)  \
309   JITTER_STACK_TOS_SET_AT_DEPTH(pvm_val, jitter_state_runtime. , stack, x0, x1)
310 
311 /* Wrapper definition of the set_at_nonzero_depth operation for the TOS-optimized stack "stack". */
312 #define JITTER_SET_AT_NONZERO_DEPTH_STACK(x0, x1)  \
313   JITTER_STACK_TOS_SET_AT_NONZERO_DEPTH(pvm_val, jitter_state_runtime. , stack, x0, x1)
314 
315 /* Wrapper definition of the push_unspecified operation for the TOS-optimized stack "stack". */
316 #define JITTER_PUSH_UNSPECIFIED_STACK()  \
317   JITTER_STACK_TOS_PUSH_UNSPECIFIED(pvm_val, jitter_state_runtime. , stack)
318 
319 /* Wrapper definition of the push operation for the TOS-optimized stack "stack". */
320 #define JITTER_PUSH_STACK(x0)  \
321   JITTER_STACK_TOS_PUSH(pvm_val, jitter_state_runtime. , stack, x0)
322 
323 /* Wrapper definition of the drop operation for the TOS-optimized stack "stack". */
324 #define JITTER_DROP_STACK()  \
325   JITTER_STACK_TOS_DROP(pvm_val, jitter_state_runtime. , stack)
326 
327 /* Wrapper definition of the dup operation for the TOS-optimized stack "stack". */
328 #define JITTER_DUP_STACK()  \
329   JITTER_STACK_TOS_DUP(pvm_val, jitter_state_runtime. , stack)
330 
331 /* Wrapper definition of the swap operation for the TOS-optimized stack "stack". */
332 #define JITTER_SWAP_STACK()  \
333   JITTER_STACK_TOS_SWAP(pvm_val, jitter_state_runtime. , stack)
334 
335 /* Wrapper definition of the quake operation for the TOS-optimized stack "stack". */
336 #define JITTER_QUAKE_STACK()  \
337   JITTER_STACK_TOS_QUAKE(pvm_val, jitter_state_runtime. , stack)
338 
339 /* Wrapper definition of the over operation for the TOS-optimized stack "stack". */
340 #define JITTER_OVER_STACK()  \
341   JITTER_STACK_TOS_OVER(pvm_val, jitter_state_runtime. , stack)
342 
343 /* Wrapper definition of the tuck operation for the TOS-optimized stack "stack". */
344 #define JITTER_TUCK_STACK()  \
345   JITTER_STACK_TOS_TUCK(pvm_val, jitter_state_runtime. , stack)
346 
347 /* Wrapper definition of the nip operation for the TOS-optimized stack "stack". */
348 #define JITTER_NIP_STACK()  \
349   JITTER_STACK_TOS_NIP(pvm_val, jitter_state_runtime. , stack)
350 
351 /* Wrapper definition of the rot operation for the TOS-optimized stack "stack". */
352 #define JITTER_ROT_STACK()  \
353   JITTER_STACK_TOS_ROT(pvm_val, jitter_state_runtime. , stack)
354 
355 /* Wrapper definition of the mrot operation for the TOS-optimized stack "stack". */
356 #define JITTER_MROT_STACK()  \
357   JITTER_STACK_TOS_MROT(pvm_val, jitter_state_runtime. , stack)
358 
359 /* Wrapper definition of the roll operation for the TOS-optimized stack "stack". */
360 #define JITTER_ROLL_STACK(x0)  \
361   JITTER_STACK_TOS_ROLL(pvm_val, jitter_state_runtime. , stack, x0)
362 
363 /* Wrapper definition of the mroll operation for the TOS-optimized stack "stack". */
364 #define JITTER_MROLL_STACK(x0)  \
365   JITTER_STACK_TOS_MROLL(pvm_val, jitter_state_runtime. , stack, x0)
366 
367 /* Wrapper definition of the slide operation for the TOS-optimized stack "stack". */
368 #define JITTER_SLIDE_STACK(x0, x1)  \
369   JITTER_STACK_TOS_SLIDE(pvm_val, jitter_state_runtime. , stack, x0, x1)
370 
371 /* Wrapper definition of the whirl operation for the TOS-optimized stack "stack". */
372 #define JITTER_WHIRL_STACK(x0)  \
373   JITTER_STACK_TOS_WHIRL(pvm_val, jitter_state_runtime. , stack, x0)
374 
375 /* Wrapper definition of the bulge operation for the TOS-optimized stack "stack". */
376 #define JITTER_BULGE_STACK(x0)  \
377   JITTER_STACK_TOS_BULGE(pvm_val, jitter_state_runtime. , stack, x0)
378 
379 /* Wrapper definition of the height operation for the TOS-optimized stack "stack". */
380 #define JITTER_HEIGHT_STACK()  \
381   JITTER_STACK_TOS_HEIGHT(pvm_val, jitter_state_runtime. , stack)
382 
383 /* Wrapper definition of the set_height operation for the TOS-optimized stack "stack". */
384 #define JITTER_SET_HEIGHT_STACK(x0)  \
385   JITTER_STACK_TOS_SET_HEIGHT(pvm_val, jitter_state_runtime. , stack, x0)
386 
387 /* Wrapper definition of the reverse operation for the TOS-optimized stack "stack". */
388 #define JITTER_REVERSE_STACK(x0)  \
389   JITTER_STACK_TOS_REVERSE(pvm_val, jitter_state_runtime. , stack, x0)
390 
391 /* Wrapper definition of the unary operation for the TOS-optimized stack "stack". */
392 #define JITTER_UNARY_STACK(x0)  \
393   JITTER_STACK_TOS_UNARY(pvm_val, jitter_state_runtime. , stack, x0)
394 
395 /* Wrapper definition of the binary operation for the TOS-optimized stack "stack". */
396 #define JITTER_BINARY_STACK(x0)  \
397   JITTER_STACK_TOS_BINARY(pvm_val, jitter_state_runtime. , stack, x0)
398 
399 /* Wrapper definition of the top operation for the non-TOS-optimized stack "returnstack". */
400 #define JITTER_TOP_RETURNSTACK()  \
401   JITTER_STACK_NTOS_TOP(pvm_val, jitter_state_runtime. , returnstack)
402 
403 /* Wrapper definition of the under_top operation for the non-TOS-optimized stack "returnstack". */
404 #define JITTER_UNDER_TOP_RETURNSTACK()  \
405   JITTER_STACK_NTOS_UNDER_TOP(pvm_val, jitter_state_runtime. , returnstack)
406 
407 /* Wrapper definition of the at_depth operation for the non-TOS-optimized stack "returnstack". */
408 #define JITTER_AT_DEPTH_RETURNSTACK(x0)  \
409   JITTER_STACK_NTOS_AT_DEPTH(pvm_val, jitter_state_runtime. , returnstack, x0)
410 
411 /* Wrapper definition of the at_nonzero_depth operation for the non-TOS-optimized stack "returnstack". */
412 #define JITTER_AT_NONZERO_DEPTH_RETURNSTACK(x0)  \
413   JITTER_STACK_NTOS_AT_NONZERO_DEPTH(pvm_val, jitter_state_runtime. , returnstack, x0)
414 
415 /* Wrapper definition of the set_at_depth operation for the non-TOS-optimized stack "returnstack". */
416 #define JITTER_SET_AT_DEPTH_RETURNSTACK(x0, x1)  \
417   JITTER_STACK_NTOS_SET_AT_DEPTH(pvm_val, jitter_state_runtime. , returnstack, x0, x1)
418 
419 /* Wrapper definition of the set_at_nonzero_depth operation for the non-TOS-optimized stack "returnstack". */
420 #define JITTER_SET_AT_NONZERO_DEPTH_RETURNSTACK(x0, x1)  \
421   JITTER_STACK_NTOS_SET_AT_NONZERO_DEPTH(pvm_val, jitter_state_runtime. , returnstack, x0, x1)
422 
423 /* Wrapper definition of the push_unspecified operation for the non-TOS-optimized stack "returnstack". */
424 #define JITTER_PUSH_UNSPECIFIED_RETURNSTACK()  \
425   JITTER_STACK_NTOS_PUSH_UNSPECIFIED(pvm_val, jitter_state_runtime. , returnstack)
426 
427 /* Wrapper definition of the push operation for the non-TOS-optimized stack "returnstack". */
428 #define JITTER_PUSH_RETURNSTACK(x0)  \
429   JITTER_STACK_NTOS_PUSH(pvm_val, jitter_state_runtime. , returnstack, x0)
430 
431 /* Wrapper definition of the drop operation for the non-TOS-optimized stack "returnstack". */
432 #define JITTER_DROP_RETURNSTACK()  \
433   JITTER_STACK_NTOS_DROP(pvm_val, jitter_state_runtime. , returnstack)
434 
435 /* Wrapper definition of the dup operation for the non-TOS-optimized stack "returnstack". */
436 #define JITTER_DUP_RETURNSTACK()  \
437   JITTER_STACK_NTOS_DUP(pvm_val, jitter_state_runtime. , returnstack)
438 
439 /* Wrapper definition of the swap operation for the non-TOS-optimized stack "returnstack". */
440 #define JITTER_SWAP_RETURNSTACK()  \
441   JITTER_STACK_NTOS_SWAP(pvm_val, jitter_state_runtime. , returnstack)
442 
443 /* Wrapper definition of the quake operation for the non-TOS-optimized stack "returnstack". */
444 #define JITTER_QUAKE_RETURNSTACK()  \
445   JITTER_STACK_NTOS_QUAKE(pvm_val, jitter_state_runtime. , returnstack)
446 
447 /* Wrapper definition of the over operation for the non-TOS-optimized stack "returnstack". */
448 #define JITTER_OVER_RETURNSTACK()  \
449   JITTER_STACK_NTOS_OVER(pvm_val, jitter_state_runtime. , returnstack)
450 
451 /* Wrapper definition of the tuck operation for the non-TOS-optimized stack "returnstack". */
452 #define JITTER_TUCK_RETURNSTACK()  \
453   JITTER_STACK_NTOS_TUCK(pvm_val, jitter_state_runtime. , returnstack)
454 
455 /* Wrapper definition of the nip operation for the non-TOS-optimized stack "returnstack". */
456 #define JITTER_NIP_RETURNSTACK()  \
457   JITTER_STACK_NTOS_NIP(pvm_val, jitter_state_runtime. , returnstack)
458 
459 /* Wrapper definition of the rot operation for the non-TOS-optimized stack "returnstack". */
460 #define JITTER_ROT_RETURNSTACK()  \
461   JITTER_STACK_NTOS_ROT(pvm_val, jitter_state_runtime. , returnstack)
462 
463 /* Wrapper definition of the mrot operation for the non-TOS-optimized stack "returnstack". */
464 #define JITTER_MROT_RETURNSTACK()  \
465   JITTER_STACK_NTOS_MROT(pvm_val, jitter_state_runtime. , returnstack)
466 
467 /* Wrapper definition of the roll operation for the non-TOS-optimized stack "returnstack". */
468 #define JITTER_ROLL_RETURNSTACK(x0)  \
469   JITTER_STACK_NTOS_ROLL(pvm_val, jitter_state_runtime. , returnstack, x0)
470 
471 /* Wrapper definition of the mroll operation for the non-TOS-optimized stack "returnstack". */
472 #define JITTER_MROLL_RETURNSTACK(x0)  \
473   JITTER_STACK_NTOS_MROLL(pvm_val, jitter_state_runtime. , returnstack, x0)
474 
475 /* Wrapper definition of the slide operation for the non-TOS-optimized stack "returnstack". */
476 #define JITTER_SLIDE_RETURNSTACK(x0, x1)  \
477   JITTER_STACK_NTOS_SLIDE(pvm_val, jitter_state_runtime. , returnstack, x0, x1)
478 
479 /* Wrapper definition of the whirl operation for the non-TOS-optimized stack "returnstack". */
480 #define JITTER_WHIRL_RETURNSTACK(x0)  \
481   JITTER_STACK_NTOS_WHIRL(pvm_val, jitter_state_runtime. , returnstack, x0)
482 
483 /* Wrapper definition of the bulge operation for the non-TOS-optimized stack "returnstack". */
484 #define JITTER_BULGE_RETURNSTACK(x0)  \
485   JITTER_STACK_NTOS_BULGE(pvm_val, jitter_state_runtime. , returnstack, x0)
486 
487 /* Wrapper definition of the height operation for the non-TOS-optimized stack "returnstack". */
488 #define JITTER_HEIGHT_RETURNSTACK()  \
489   JITTER_STACK_NTOS_HEIGHT(pvm_val, jitter_state_runtime. , returnstack)
490 
491 /* Wrapper definition of the set_height operation for the non-TOS-optimized stack "returnstack". */
492 #define JITTER_SET_HEIGHT_RETURNSTACK(x0)  \
493   JITTER_STACK_NTOS_SET_HEIGHT(pvm_val, jitter_state_runtime. , returnstack, x0)
494 
495 /* Wrapper definition of the reverse operation for the non-TOS-optimized stack "returnstack". */
496 #define JITTER_REVERSE_RETURNSTACK(x0)  \
497   JITTER_STACK_NTOS_REVERSE(pvm_val, jitter_state_runtime. , returnstack, x0)
498 
499 /* Wrapper definition of the unary operation for the non-TOS-optimized stack "returnstack". */
500 #define JITTER_UNARY_RETURNSTACK(x0)  \
501   JITTER_STACK_NTOS_UNARY(pvm_val, jitter_state_runtime. , returnstack, x0)
502 
503 /* Wrapper definition of the binary operation for the non-TOS-optimized stack "returnstack". */
504 #define JITTER_BINARY_RETURNSTACK(x0)  \
505   JITTER_STACK_NTOS_BINARY(pvm_val, jitter_state_runtime. , returnstack, x0)
506 
507 /* Wrapper definition of the top operation for the non-TOS-optimized stack "exceptionstack". */
508 #define JITTER_TOP_EXCEPTIONSTACK()  \
509   JITTER_STACK_NTOS_TOP(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
510 
511 /* Wrapper definition of the under_top operation for the non-TOS-optimized stack "exceptionstack". */
512 #define JITTER_UNDER_TOP_EXCEPTIONSTACK()  \
513   JITTER_STACK_NTOS_UNDER_TOP(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
514 
515 /* Wrapper definition of the at_depth operation for the non-TOS-optimized stack "exceptionstack". */
516 #define JITTER_AT_DEPTH_EXCEPTIONSTACK(x0)  \
517   JITTER_STACK_NTOS_AT_DEPTH(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
518 
519 /* Wrapper definition of the at_nonzero_depth operation for the non-TOS-optimized stack "exceptionstack". */
520 #define JITTER_AT_NONZERO_DEPTH_EXCEPTIONSTACK(x0)  \
521   JITTER_STACK_NTOS_AT_NONZERO_DEPTH(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
522 
523 /* Wrapper definition of the set_at_depth operation for the non-TOS-optimized stack "exceptionstack". */
524 #define JITTER_SET_AT_DEPTH_EXCEPTIONSTACK(x0, x1)  \
525   JITTER_STACK_NTOS_SET_AT_DEPTH(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0, x1)
526 
527 /* Wrapper definition of the set_at_nonzero_depth operation for the non-TOS-optimized stack "exceptionstack". */
528 #define JITTER_SET_AT_NONZERO_DEPTH_EXCEPTIONSTACK(x0, x1)  \
529   JITTER_STACK_NTOS_SET_AT_NONZERO_DEPTH(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0, x1)
530 
531 /* Wrapper definition of the push_unspecified operation for the non-TOS-optimized stack "exceptionstack". */
532 #define JITTER_PUSH_UNSPECIFIED_EXCEPTIONSTACK()  \
533   JITTER_STACK_NTOS_PUSH_UNSPECIFIED(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
534 
535 /* Wrapper definition of the push operation for the non-TOS-optimized stack "exceptionstack". */
536 #define JITTER_PUSH_EXCEPTIONSTACK(x0)  \
537   JITTER_STACK_NTOS_PUSH(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
538 
539 /* Wrapper definition of the drop operation for the non-TOS-optimized stack "exceptionstack". */
540 #define JITTER_DROP_EXCEPTIONSTACK()  \
541   JITTER_STACK_NTOS_DROP(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
542 
543 /* Wrapper definition of the dup operation for the non-TOS-optimized stack "exceptionstack". */
544 #define JITTER_DUP_EXCEPTIONSTACK()  \
545   JITTER_STACK_NTOS_DUP(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
546 
547 /* Wrapper definition of the swap operation for the non-TOS-optimized stack "exceptionstack". */
548 #define JITTER_SWAP_EXCEPTIONSTACK()  \
549   JITTER_STACK_NTOS_SWAP(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
550 
551 /* Wrapper definition of the quake operation for the non-TOS-optimized stack "exceptionstack". */
552 #define JITTER_QUAKE_EXCEPTIONSTACK()  \
553   JITTER_STACK_NTOS_QUAKE(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
554 
555 /* Wrapper definition of the over operation for the non-TOS-optimized stack "exceptionstack". */
556 #define JITTER_OVER_EXCEPTIONSTACK()  \
557   JITTER_STACK_NTOS_OVER(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
558 
559 /* Wrapper definition of the tuck operation for the non-TOS-optimized stack "exceptionstack". */
560 #define JITTER_TUCK_EXCEPTIONSTACK()  \
561   JITTER_STACK_NTOS_TUCK(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
562 
563 /* Wrapper definition of the nip operation for the non-TOS-optimized stack "exceptionstack". */
564 #define JITTER_NIP_EXCEPTIONSTACK()  \
565   JITTER_STACK_NTOS_NIP(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
566 
567 /* Wrapper definition of the rot operation for the non-TOS-optimized stack "exceptionstack". */
568 #define JITTER_ROT_EXCEPTIONSTACK()  \
569   JITTER_STACK_NTOS_ROT(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
570 
571 /* Wrapper definition of the mrot operation for the non-TOS-optimized stack "exceptionstack". */
572 #define JITTER_MROT_EXCEPTIONSTACK()  \
573   JITTER_STACK_NTOS_MROT(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
574 
575 /* Wrapper definition of the roll operation for the non-TOS-optimized stack "exceptionstack". */
576 #define JITTER_ROLL_EXCEPTIONSTACK(x0)  \
577   JITTER_STACK_NTOS_ROLL(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
578 
579 /* Wrapper definition of the mroll operation for the non-TOS-optimized stack "exceptionstack". */
580 #define JITTER_MROLL_EXCEPTIONSTACK(x0)  \
581   JITTER_STACK_NTOS_MROLL(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
582 
583 /* Wrapper definition of the slide operation for the non-TOS-optimized stack "exceptionstack". */
584 #define JITTER_SLIDE_EXCEPTIONSTACK(x0, x1)  \
585   JITTER_STACK_NTOS_SLIDE(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0, x1)
586 
587 /* Wrapper definition of the whirl operation for the non-TOS-optimized stack "exceptionstack". */
588 #define JITTER_WHIRL_EXCEPTIONSTACK(x0)  \
589   JITTER_STACK_NTOS_WHIRL(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
590 
591 /* Wrapper definition of the bulge operation for the non-TOS-optimized stack "exceptionstack". */
592 #define JITTER_BULGE_EXCEPTIONSTACK(x0)  \
593   JITTER_STACK_NTOS_BULGE(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
594 
595 /* Wrapper definition of the height operation for the non-TOS-optimized stack "exceptionstack". */
596 #define JITTER_HEIGHT_EXCEPTIONSTACK()  \
597   JITTER_STACK_NTOS_HEIGHT(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack)
598 
599 /* Wrapper definition of the set_height operation for the non-TOS-optimized stack "exceptionstack". */
600 #define JITTER_SET_HEIGHT_EXCEPTIONSTACK(x0)  \
601   JITTER_STACK_NTOS_SET_HEIGHT(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
602 
603 /* Wrapper definition of the reverse operation for the non-TOS-optimized stack "exceptionstack". */
604 #define JITTER_REVERSE_EXCEPTIONSTACK(x0)  \
605   JITTER_STACK_NTOS_REVERSE(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
606 
607 /* Wrapper definition of the unary operation for the non-TOS-optimized stack "exceptionstack". */
608 #define JITTER_UNARY_EXCEPTIONSTACK(x0)  \
609   JITTER_STACK_NTOS_UNARY(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
610 
611 /* Wrapper definition of the binary operation for the non-TOS-optimized stack "exceptionstack". */
612 #define JITTER_BINARY_EXCEPTIONSTACK(x0)  \
613   JITTER_STACK_NTOS_BINARY(struct pvm_exception_handler, jitter_state_runtime. , exceptionstack, x0)
614 
615 /* Late C code from the user. */
616 #line 686 "../../libpoke/pvm.jitter"
617 #line 686 "../../libpoke/pvm.jitter"
618 
619     void
pvm_handle_signal(int signal_number)620     pvm_handle_signal (int signal_number)
621     {
622       struct pvm_state *s;
623 
624       /* For every state... */
625       PVM_FOR_EACH_STATE (s)
626       {
627         /* ...Mark the signal signal_number as pending... */
628         PVM_STATE_AND_SIGNAL_TO_PENDING_SIGNAL_NOTIFICATION
629            (s, signal_number) = true;
630         /* ...And record the fact that there is at least one notification to
631            handle. */
632         PVM_STATE_TO_PENDING_NOTIFICATIONS (s) = true;
633       }
634     }
635   /* End of the late C code from the user. */
636 
637 /* The definition of this is machine-generated in pvm-vm2.c , and the
638    function is not intended for the user.  If initializing then set
639    structuredvm_threads and structuredvm_thread_sizes and just return, ignoring
640    the other fieldsp and s.  If not initializing then actually enter VM code
641    starting from the given program point in the pointed state. */
642 static void
643 pvm_execute_or_initialize (bool jitter_initialize,
644                                 pvm_program_point jitter_initial_program_point,
645                                 struct pvm_state * const jitter_original_state)
646   __attribute__ ((noclone, noinline));
647 
648 void
pvm_execute_executable_routine(const struct jitter_executable_routine * er,struct pvm_state * s)649 pvm_execute_executable_routine (const struct jitter_executable_routine *er,
650                                      struct pvm_state *s)
651 {
652   pvm_make_place_for_slow_registers (s, er->slow_register_per_class_no);
653   jitter_program_point initial_program_point
654     = PVM_EXECUTABLE_ROUTINE_BEGINNING (er);
655   pvm_execute_or_initialize (false, initial_program_point, s);
656 }
657 
658 
659 /* Threads or pointers to native code blocks of course don't exist with
660    switch-dispatching. */
661 #ifndef JITTER_DISPATCH_SWITCH
662 const jitter_thread *
663 pvm_threads;
664 
665 const jitter_thread *
666 pvm_thread_ends;
667 
668 const long *
669 pvm_thread_sizes;
670 #endif // #ifndef JITTER_DISPATCH_SWITCH
671 
672 void
pvm_initialize_threads(void)673 pvm_initialize_threads (void)
674 {
675   pvm_execute_or_initialize (true, NULL, NULL);
676 }
677 
678 void
pvm_branch_to_program_point(pvm_program_point p,struct pvm_state * s)679 pvm_branch_to_program_point (pvm_program_point p, struct pvm_state *s)
680 {
681   pvm_execute_or_initialize (false, p, s);
682 }
683 
684 static void
pvm_execute_or_initialize(bool jitter_initialize,pvm_program_point jitter_initial_program_point,struct pvm_state * const jitter_original_state)685 pvm_execute_or_initialize (bool jitter_initialize,
686                                 pvm_program_point jitter_initial_program_point,
687                                 struct pvm_state * const jitter_original_state)
688 {
689 #ifdef JITTER_DISPATCH_NO_THREADING
690   /* Save the values in the registers we reserved as global variables,
691      since from the point of view of the other C compilation units such
692      registers are callee-save.  FIXME: this is not really needed when
693      initializing, if I've been careful; but for the time being I want
694      to play it safe. */
695   union jitter_word jitter_register_buffer [PVM_REGISTER_BUFFER_ELEMENT_NO];
696   pvm_save_registers (jitter_register_buffer);
697 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
698 
699 #ifdef JITTER_HAVE_PATCH_IN
700   /* Generate the single patch-in header for this executor as a
701      global asm statement.  This expands into a global definition in
702      assembly in a separate subsection, and relies on toplevel C
703      definitions not being reordered: pvm_execute_or_initialize
704      will add to the same global.  Do the same for defects. */
705   JITTER_DEFECT_HEADER(pvm);
706   JITTER_PATCH_IN_HEADER(pvm);
707 #endif // #ifdef JITTER_HAVE_PATCH_IN
708 
709 #ifndef JITTER_DISPATCH_SWITCH
710   JITTER_DATA_LOCATION_HEADER(pvm);
711 #endif // #ifndef JITTER_DISPATCH_SWITCH
712 
713   /* Initialization.  This is only called once at startup. */
714   if (__builtin_expect (jitter_initialize, false))
715     {
716       /* Make sure that vm1 and vm2 were macroexpanded consistently
717          with respect to instrumentation macros.  This relies on the
718          enum values for each feature working as individual bits in a
719          bitmask: see the comment in jitter/jitter-vm.h . */
720       enum jitter_vm_instrumentation correct_instrumentation
721         = jitter_vm_instrumentation_none;
722 #if defined (JITTER_PROFILE_COUNT)
723       correct_instrumentation |= jitter_vm_instrumentation_count;
724 #endif
725 #if defined (JITTER_PROFILE_SAMPLE)
726       correct_instrumentation |= jitter_vm_instrumentation_sample;
727 #endif
728       if (pvm_vm_configuration->instrumentation != correct_instrumentation)
729         jitter_fatal ("vm1 and vm2 were compiled with different profiling "
730                       "instrumentation macros.  Please recompile with coherent "
731                       "CPPFLAGS");
732 
733 #if defined (JITTER_PROFILE_SAMPLE)
734     /* Initialise the sample-profile subsystem, once and for all. */
735     pvm_profile_sample_initialize ();
736 #endif // #if defined (JITTER_PROFILE_SAMPLE)
737 
738 #ifndef JITTER_DISPATCH_SWITCH
739       /* FIXME: I can do this with only one relocation, by keeping
740          a pointer to the first VM instruction beginning in a static
741          variable, and then having a static vector of offsets with
742          respect to the first pointer.  This will slightly complicate
743          my initialization code, but should make startup faster.
744          FIXME: that won't work on AVR, according to the GCC
745          documentation.  Do I care?  Probably not, since AVRs can't
746          address more than 2^16 bytes, which is too little to run my
747          VMs. */
748       static const jitter_thread pvm_the_threads []
749         = {
750             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID),
751             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eBEGINBASICBLOCK),
752             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eEXITVM),
753             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eDATALOCATIONS),
754             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eNOP),
755             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE0),
756             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE1),
757             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE2),
758             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addi),
759             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addiu),
760             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addl),
761             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addlu),
762             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ains),
763             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(and),
764             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(aref),
765             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(arefo),
766             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(arem),
767             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(aset),
768             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(asettb),
769             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(atr),
770             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ba__fR),
771             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandi),
772             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandiu),
773             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandl),
774             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandlu),
775             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(beghl),
776             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(begsc),
777             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bn__fR),
778             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnn__fR),
779             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnoti),
780             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotiu),
781             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotl),
782             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotlu),
783             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzi__fR),
784             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnziu__fR),
785             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzl__fR),
786             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzlu__fR),
787             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bori),
788             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(boriu),
789             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(borl),
790             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(borlu),
791             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsli),
792             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsliu),
793             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsll),
794             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsllu),
795             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsri),
796             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsriu),
797             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsrl),
798             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsrlu),
799             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxori),
800             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxoriu),
801             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxorl),
802             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxorlu),
803             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzi__fR),
804             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bziu__fR),
805             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzl__fR),
806             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzlu__fR),
807             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__retR),
808             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(canary),
809             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(close),
810             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ctos),
811             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(disas),
812             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divi),
813             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(diviu),
814             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divl),
815             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divlu),
816             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop),
817             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop2),
818             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop3),
819             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop4),
820             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(duc),
821             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(dup),
822             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(endhl),
823             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(endsc),
824             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqi),
825             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqiu),
826             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eql),
827             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqlu),
828             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqs),
829             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exit),
830             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exitvm),
831             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(flush),
832             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(fromr),
833             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gei),
834             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(geiu),
835             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gel),
836             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gelu),
837             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ges),
838             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(getenv),
839             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gti),
840             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtiu),
841             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtl),
842             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtlu),
843             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gts),
844             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(indent),
845             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iogetb),
846             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iosetb),
847             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iosize),
848             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(isa),
849             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itoi__nR),
850             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itoiu__nR),
851             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itol__nR),
852             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itolu__nR),
853             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutoi__nR),
854             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutoiu__nR),
855             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutol__nR),
856             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutolu__nR),
857             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lei),
858             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(leiu),
859             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lel),
860             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lelu),
861             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(les),
862             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lti),
863             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltiu),
864             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltl),
865             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltlu),
866             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltoi__nR),
867             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltoiu__nR),
868             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltol__nR),
869             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltolu__nR),
870             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lts),
871             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutoi__nR),
872             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutoiu__nR),
873             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutol__nR),
874             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutolu__nR),
875             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(map),
876             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetios),
877             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetm),
878             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgeto),
879             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgets),
880             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetsel),
881             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetsiz),
882             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetw),
883             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mka),
884             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mko),
885             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mksct),
886             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktya),
887             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyany),
888             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyc),
889             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyi),
890             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyo),
891             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktys),
892             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktysct),
893             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyv),
894             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mm),
895             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modi),
896             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modiu),
897             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modl),
898             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modlu),
899             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetios),
900             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetm),
901             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mseto),
902             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msets),
903             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetsel),
904             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetsiz),
905             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetw),
906             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muli),
907             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muliu),
908             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mull),
909             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mullu),
910             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muls),
911             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negi),
912             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negiu),
913             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negl),
914             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(neglu),
915             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nei),
916             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(neiu),
917             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nel),
918             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nelu),
919             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nes),
920             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip),
921             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip2),
922             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip3),
923             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nn),
924             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nnn),
925             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nop),
926             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(not),
927             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(note__nR),
928             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nrot),
929             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetbt),
930             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetm),
931             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetu),
932             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(open),
933             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(or),
934             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(osetm),
935             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(over),
936             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pec),
937             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdi__nR),
938             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdiu__nR),
939             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdl__nR),
940             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdlu__nR),
941             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeki__nR__nR__nR),
942             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekiu__nR__nR),
943             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekl__nR__nR__nR),
944             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeklu__nR__nR),
945             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeks),
946             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedi__nR),
947             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokediu__nR),
948             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedl__nR),
949             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedlu__nR),
950             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokei__nR__nR__nR),
951             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokeiu__nR__nR),
952             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokel__nR__nR__nR),
953             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokelu__nR__nR),
954             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokes),
955             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pope),
956             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popend),
957             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popf__nR),
958             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popios),
959             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoac),
960             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popob),
961             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popobc),
962             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoc),
963             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popod),
964             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoi),
965             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popom),
966             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoo),
967             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popopp),
968             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popr___rrR),
969             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popvar__nR__nR),
970             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powi),
971             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powiu),
972             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powl),
973             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powlu),
974             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printi__nR),
975             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printiu__nR),
976             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printl__nR),
977             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printlu__nR),
978             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(prints),
979             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(prolog),
980             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push__nR),
981             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push__lR),
982             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push32__nR),
983             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push32__lR),
984             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushe__lR),
985             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushend),
986             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushf__nR),
987             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushhi__nR),
988             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushhi__lR),
989             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushios),
990             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushlo__nR),
991             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushlo__lR),
992             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoac),
993             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushob),
994             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushobc),
995             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoc),
996             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushod),
997             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoi),
998             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushom),
999             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoo),
1000             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushopp),
1001             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushr___rrR),
1002             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushtopvar__nR),
1003             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n0),
1004             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n1),
1005             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n2),
1006             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n3),
1007             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n4),
1008             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n5),
1009             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__nR),
1010             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n0),
1011             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n1),
1012             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n2),
1013             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n3),
1014             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n4),
1015             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n5),
1016             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__nR),
1017             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(quake),
1018             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(raise),
1019             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(rand),
1020             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(regvar),
1021             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(reloc),
1022             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(restorer___rrR),
1023             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(return),
1024             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__n3),
1025             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__n4),
1026             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__nR),
1027             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(rot),
1028             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(saver___rrR),
1029             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sconc),
1030             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sel),
1031             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(setr___rrR),
1032             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(siz),
1033             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(smodi),
1034             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sref),
1035             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefi),
1036             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefia),
1037             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefio),
1038             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefmnt),
1039             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefnt),
1040             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefo),
1041             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sset),
1042             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(strace__nR),
1043             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(strref),
1044             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subi),
1045             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subiu),
1046             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subl),
1047             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sublu),
1048             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(substr),
1049             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swap),
1050             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgti),
1051             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtiu),
1052             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtl),
1053             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtlu),
1054             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sync),
1055             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(time),
1056             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tor),
1057             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tuck),
1058             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyagetb),
1059             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyagett),
1060             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyisc),
1061             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyissct),
1062             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(typof),
1063             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tysctn),
1064             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unmap),
1065             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unreachable),
1066             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ureloc),
1067             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(write__retR),
1068             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aba__fR_A_mno_mfast_mbranches),
1069             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abn__fR_A_mno_mfast_mbranches),
1070             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnn__fR_A_mno_mfast_mbranches),
1071             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzi__fR_A_mno_mfast_mbranches),
1072             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnziu__fR_A_mno_mfast_mbranches),
1073             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzl__fR_A_mno_mfast_mbranches),
1074             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzlu__fR_A_mno_mfast_mbranches),
1075             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzi__fR_A_mno_mfast_mbranches),
1076             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abziu__fR_A_mno_mfast_mbranches),
1077             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzl__fR_A_mno_mfast_mbranches),
1078             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzlu__fR_A_mno_mfast_mbranches)
1079           };
1080       static const jitter_thread pvm_the_thread_ends []
1081         = {
1082             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eINVALID),
1083             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eBEGINBASICBLOCK),
1084             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eEXITVM),
1085             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eDATALOCATIONS),
1086             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eNOP),
1087             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE0),
1088             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE1),
1089             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE2),
1090             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addi),
1091             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addiu),
1092             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addl),
1093             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addlu),
1094             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ains),
1095             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(and),
1096             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(aref),
1097             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(arefo),
1098             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(arem),
1099             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(aset),
1100             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(asettb),
1101             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(atr),
1102             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ba__fR),
1103             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandi),
1104             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandiu),
1105             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandl),
1106             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandlu),
1107             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(beghl),
1108             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(begsc),
1109             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bn__fR),
1110             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnn__fR),
1111             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnoti),
1112             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnotiu),
1113             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnotl),
1114             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnotlu),
1115             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnzi__fR),
1116             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnziu__fR),
1117             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnzl__fR),
1118             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnzlu__fR),
1119             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bori),
1120             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(boriu),
1121             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(borl),
1122             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(borlu),
1123             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsli),
1124             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsliu),
1125             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsll),
1126             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsllu),
1127             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsri),
1128             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsriu),
1129             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsrl),
1130             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsrlu),
1131             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxori),
1132             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxoriu),
1133             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxorl),
1134             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxorlu),
1135             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bzi__fR),
1136             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bziu__fR),
1137             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bzl__fR),
1138             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bzlu__fR),
1139             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__retR),
1140             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(canary),
1141             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(close),
1142             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ctos),
1143             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(disas),
1144             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(divi),
1145             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(diviu),
1146             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(divl),
1147             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(divlu),
1148             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop),
1149             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop2),
1150             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop3),
1151             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop4),
1152             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(duc),
1153             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(dup),
1154             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(endhl),
1155             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(endsc),
1156             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqi),
1157             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqiu),
1158             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eql),
1159             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqlu),
1160             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqs),
1161             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(exit),
1162             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(exitvm),
1163             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(flush),
1164             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(fromr),
1165             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gei),
1166             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(geiu),
1167             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gel),
1168             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gelu),
1169             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ges),
1170             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(getenv),
1171             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gti),
1172             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gtiu),
1173             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gtl),
1174             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gtlu),
1175             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gts),
1176             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(indent),
1177             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iogetb),
1178             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iosetb),
1179             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iosize),
1180             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(isa),
1181             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itoi__nR),
1182             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itoiu__nR),
1183             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itol__nR),
1184             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itolu__nR),
1185             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutoi__nR),
1186             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutoiu__nR),
1187             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutol__nR),
1188             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutolu__nR),
1189             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lei),
1190             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(leiu),
1191             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lel),
1192             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lelu),
1193             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(les),
1194             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lti),
1195             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltiu),
1196             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltl),
1197             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltlu),
1198             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltoi__nR),
1199             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltoiu__nR),
1200             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltol__nR),
1201             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltolu__nR),
1202             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lts),
1203             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutoi__nR),
1204             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutoiu__nR),
1205             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutol__nR),
1206             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutolu__nR),
1207             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(map),
1208             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetios),
1209             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetm),
1210             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgeto),
1211             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgets),
1212             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetsel),
1213             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetsiz),
1214             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetw),
1215             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mka),
1216             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mko),
1217             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mksct),
1218             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktya),
1219             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyany),
1220             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyc),
1221             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyi),
1222             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyo),
1223             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktys),
1224             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktysct),
1225             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyv),
1226             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mm),
1227             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modi),
1228             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modiu),
1229             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modl),
1230             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modlu),
1231             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetios),
1232             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetm),
1233             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mseto),
1234             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msets),
1235             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetsel),
1236             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetsiz),
1237             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetw),
1238             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(muli),
1239             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(muliu),
1240             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mull),
1241             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mullu),
1242             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(muls),
1243             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(negi),
1244             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(negiu),
1245             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(negl),
1246             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(neglu),
1247             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nei),
1248             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(neiu),
1249             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nel),
1250             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nelu),
1251             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nes),
1252             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip),
1253             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip2),
1254             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip3),
1255             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nn),
1256             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nnn),
1257             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nop),
1258             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(not),
1259             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(note__nR),
1260             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nrot),
1261             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ogetbt),
1262             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ogetm),
1263             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ogetu),
1264             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(open),
1265             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(or),
1266             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(osetm),
1267             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(over),
1268             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pec),
1269             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdi__nR),
1270             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdiu__nR),
1271             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdl__nR),
1272             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdlu__nR),
1273             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peeki__nR__nR__nR),
1274             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekiu__nR__nR),
1275             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekl__nR__nR__nR),
1276             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peeklu__nR__nR),
1277             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peeks),
1278             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokedi__nR),
1279             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokediu__nR),
1280             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokedl__nR),
1281             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokedlu__nR),
1282             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokei__nR__nR__nR),
1283             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokeiu__nR__nR),
1284             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokel__nR__nR__nR),
1285             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokelu__nR__nR),
1286             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokes),
1287             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pope),
1288             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popend),
1289             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popf__nR),
1290             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popios),
1291             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoac),
1292             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popob),
1293             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popobc),
1294             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoc),
1295             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popod),
1296             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoi),
1297             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popom),
1298             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoo),
1299             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popopp),
1300             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popr___rrR),
1301             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popvar__nR__nR),
1302             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powi),
1303             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powiu),
1304             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powl),
1305             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powlu),
1306             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printi__nR),
1307             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printiu__nR),
1308             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printl__nR),
1309             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printlu__nR),
1310             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(prints),
1311             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(prolog),
1312             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push__nR),
1313             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push__lR),
1314             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push32__nR),
1315             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push32__lR),
1316             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushe__lR),
1317             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushend),
1318             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushf__nR),
1319             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushhi__nR),
1320             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushhi__lR),
1321             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushios),
1322             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushlo__nR),
1323             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushlo__lR),
1324             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoac),
1325             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushob),
1326             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushobc),
1327             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoc),
1328             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushod),
1329             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoi),
1330             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushom),
1331             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoo),
1332             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushopp),
1333             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushr___rrR),
1334             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushtopvar__nR),
1335             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n0),
1336             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n1),
1337             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n2),
1338             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n3),
1339             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n4),
1340             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n5),
1341             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__nR),
1342             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n0),
1343             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n1),
1344             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n2),
1345             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n3),
1346             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n4),
1347             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n5),
1348             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__nR),
1349             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(quake),
1350             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(raise),
1351             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(rand),
1352             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(regvar),
1353             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(reloc),
1354             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(restorer___rrR),
1355             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(return),
1356             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(revn__n3),
1357             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(revn__n4),
1358             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(revn__nR),
1359             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(rot),
1360             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(saver___rrR),
1361             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sconc),
1362             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sel),
1363             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(setr___rrR),
1364             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(siz),
1365             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(smodi),
1366             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sref),
1367             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefi),
1368             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefia),
1369             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefio),
1370             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefmnt),
1371             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefnt),
1372             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefo),
1373             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sset),
1374             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(strace__nR),
1375             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(strref),
1376             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(subi),
1377             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(subiu),
1378             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(subl),
1379             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sublu),
1380             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(substr),
1381             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swap),
1382             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgti),
1383             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgtiu),
1384             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgtl),
1385             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgtlu),
1386             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sync),
1387             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(time),
1388             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tor),
1389             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tuck),
1390             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyagetb),
1391             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyagett),
1392             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyisc),
1393             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyissct),
1394             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(typof),
1395             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tysctn),
1396             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(unmap),
1397             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(unreachable),
1398             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ureloc),
1399             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(write__retR),
1400             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aba__fR_A_mno_mfast_mbranches),
1401             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abn__fR_A_mno_mfast_mbranches),
1402             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnn__fR_A_mno_mfast_mbranches),
1403             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnzi__fR_A_mno_mfast_mbranches),
1404             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnziu__fR_A_mno_mfast_mbranches),
1405             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnzl__fR_A_mno_mfast_mbranches),
1406             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnzlu__fR_A_mno_mfast_mbranches),
1407             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abzi__fR_A_mno_mfast_mbranches),
1408             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abziu__fR_A_mno_mfast_mbranches),
1409             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abzl__fR_A_mno_mfast_mbranches),
1410             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abzlu__fR_A_mno_mfast_mbranches)
1411           };
1412       static const long
1413       pvm_the_thread_sizes [PVM_SPECIALIZED_INSTRUCTION_NO]
1414         = {
1415             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eINVALID))
1416                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID))),
1417             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eBEGINBASICBLOCK))
1418                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eBEGINBASICBLOCK))),
1419             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eEXITVM))
1420                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eEXITVM))),
1421             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eDATALOCATIONS))
1422                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eDATALOCATIONS))),
1423             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eNOP))
1424                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eNOP))),
1425             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE0))
1426                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE0))),
1427             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE1))
1428                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE1))),
1429             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE2))
1430                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE2))),
1431             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addi))
1432                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addi))),
1433             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addiu))
1434                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addiu))),
1435             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addl))
1436                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addl))),
1437             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(addlu))
1438                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addlu))),
1439             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ains))
1440                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ains))),
1441             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(and))
1442                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(and))),
1443             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(aref))
1444                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(aref))),
1445             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(arefo))
1446                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(arefo))),
1447             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(arem))
1448                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(arem))),
1449             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(aset))
1450                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(aset))),
1451             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(asettb))
1452                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(asettb))),
1453             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(atr))
1454                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(atr))),
1455             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ba__fR))
1456                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ba__fR))),
1457             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandi))
1458                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandi))),
1459             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandiu))
1460                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandiu))),
1461             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandl))
1462                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandl))),
1463             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bandlu))
1464                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandlu))),
1465             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(beghl))
1466                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(beghl))),
1467             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(begsc))
1468                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(begsc))),
1469             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bn__fR))
1470                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bn__fR))),
1471             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnn__fR))
1472                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnn__fR))),
1473             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnoti))
1474                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnoti))),
1475             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnotiu))
1476                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotiu))),
1477             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnotl))
1478                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotl))),
1479             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnotlu))
1480                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotlu))),
1481             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnzi__fR))
1482                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzi__fR))),
1483             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnziu__fR))
1484                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnziu__fR))),
1485             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnzl__fR))
1486                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzl__fR))),
1487             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bnzlu__fR))
1488                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzlu__fR))),
1489             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bori))
1490                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bori))),
1491             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(boriu))
1492                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(boriu))),
1493             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(borl))
1494                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(borl))),
1495             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(borlu))
1496                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(borlu))),
1497             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsli))
1498                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsli))),
1499             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsliu))
1500                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsliu))),
1501             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsll))
1502                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsll))),
1503             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsllu))
1504                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsllu))),
1505             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsri))
1506                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsri))),
1507             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsriu))
1508                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsriu))),
1509             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsrl))
1510                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsrl))),
1511             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bsrlu))
1512                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsrlu))),
1513             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxori))
1514                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxori))),
1515             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxoriu))
1516                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxoriu))),
1517             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxorl))
1518                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxorl))),
1519             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bxorlu))
1520                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxorlu))),
1521             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bzi__fR))
1522                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzi__fR))),
1523             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bziu__fR))
1524                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bziu__fR))),
1525             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bzl__fR))
1526                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzl__fR))),
1527             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(bzlu__fR))
1528                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzlu__fR))),
1529             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__retR))
1530                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__retR))),
1531             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(canary))
1532                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(canary))),
1533             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(close))
1534                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(close))),
1535             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ctos))
1536                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ctos))),
1537             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(disas))
1538                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(disas))),
1539             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(divi))
1540                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divi))),
1541             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(diviu))
1542                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(diviu))),
1543             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(divl))
1544                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divl))),
1545             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(divlu))
1546                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divlu))),
1547             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop))
1548                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop))),
1549             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop2))
1550                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop2))),
1551             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop3))
1552                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop3))),
1553             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop4))
1554                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop4))),
1555             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(duc))
1556                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(duc))),
1557             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(dup))
1558                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(dup))),
1559             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(endhl))
1560                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(endhl))),
1561             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(endsc))
1562                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(endsc))),
1563             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqi))
1564                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqi))),
1565             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqiu))
1566                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqiu))),
1567             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eql))
1568                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eql))),
1569             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqlu))
1570                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqlu))),
1571             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(eqs))
1572                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqs))),
1573             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(exit))
1574                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exit))),
1575             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(exitvm))
1576                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exitvm))),
1577             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(flush))
1578                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(flush))),
1579             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(fromr))
1580                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(fromr))),
1581             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gei))
1582                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gei))),
1583             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(geiu))
1584                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(geiu))),
1585             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gel))
1586                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gel))),
1587             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gelu))
1588                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gelu))),
1589             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ges))
1590                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ges))),
1591             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(getenv))
1592                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(getenv))),
1593             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gti))
1594                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gti))),
1595             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gtiu))
1596                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtiu))),
1597             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gtl))
1598                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtl))),
1599             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gtlu))
1600                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtlu))),
1601             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gts))
1602                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gts))),
1603             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(indent))
1604                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(indent))),
1605             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iogetb))
1606                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iogetb))),
1607             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iosetb))
1608                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iosetb))),
1609             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iosize))
1610                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iosize))),
1611             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(isa))
1612                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(isa))),
1613             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itoi__nR))
1614                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itoi__nR))),
1615             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itoiu__nR))
1616                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itoiu__nR))),
1617             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itol__nR))
1618                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itol__nR))),
1619             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(itolu__nR))
1620                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itolu__nR))),
1621             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutoi__nR))
1622                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutoi__nR))),
1623             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutoiu__nR))
1624                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutoiu__nR))),
1625             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutol__nR))
1626                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutol__nR))),
1627             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(iutolu__nR))
1628                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutolu__nR))),
1629             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lei))
1630                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lei))),
1631             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(leiu))
1632                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(leiu))),
1633             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lel))
1634                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lel))),
1635             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lelu))
1636                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lelu))),
1637             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(les))
1638                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(les))),
1639             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lti))
1640                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lti))),
1641             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltiu))
1642                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltiu))),
1643             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltl))
1644                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltl))),
1645             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltlu))
1646                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltlu))),
1647             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltoi__nR))
1648                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltoi__nR))),
1649             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltoiu__nR))
1650                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltoiu__nR))),
1651             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltol__nR))
1652                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltol__nR))),
1653             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ltolu__nR))
1654                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltolu__nR))),
1655             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lts))
1656                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lts))),
1657             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutoi__nR))
1658                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutoi__nR))),
1659             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutoiu__nR))
1660                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutoiu__nR))),
1661             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutol__nR))
1662                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutol__nR))),
1663             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(lutolu__nR))
1664                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutolu__nR))),
1665             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(map))
1666                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(map))),
1667             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetios))
1668                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetios))),
1669             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetm))
1670                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetm))),
1671             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgeto))
1672                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgeto))),
1673             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgets))
1674                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgets))),
1675             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetsel))
1676                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetsel))),
1677             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetsiz))
1678                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetsiz))),
1679             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mgetw))
1680                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetw))),
1681             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mka))
1682                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mka))),
1683             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mko))
1684                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mko))),
1685             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mksct))
1686                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mksct))),
1687             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktya))
1688                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktya))),
1689             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyany))
1690                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyany))),
1691             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyc))
1692                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyc))),
1693             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyi))
1694                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyi))),
1695             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyo))
1696                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyo))),
1697             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktys))
1698                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktys))),
1699             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktysct))
1700                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktysct))),
1701             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mktyv))
1702                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyv))),
1703             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mm))
1704                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mm))),
1705             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modi))
1706                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modi))),
1707             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modiu))
1708                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modiu))),
1709             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modl))
1710                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modl))),
1711             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(modlu))
1712                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modlu))),
1713             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetios))
1714                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetios))),
1715             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetm))
1716                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetm))),
1717             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mseto))
1718                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mseto))),
1719             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msets))
1720                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msets))),
1721             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetsel))
1722                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetsel))),
1723             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetsiz))
1724                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetsiz))),
1725             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(msetw))
1726                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetw))),
1727             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(muli))
1728                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muli))),
1729             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(muliu))
1730                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muliu))),
1731             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mull))
1732                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mull))),
1733             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(mullu))
1734                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mullu))),
1735             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(muls))
1736                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muls))),
1737             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(negi))
1738                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negi))),
1739             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(negiu))
1740                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negiu))),
1741             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(negl))
1742                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negl))),
1743             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(neglu))
1744                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(neglu))),
1745             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nei))
1746                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nei))),
1747             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(neiu))
1748                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(neiu))),
1749             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nel))
1750                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nel))),
1751             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nelu))
1752                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nelu))),
1753             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nes))
1754                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nes))),
1755             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip))
1756                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip))),
1757             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip2))
1758                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip2))),
1759             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip3))
1760                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip3))),
1761             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nn))
1762                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nn))),
1763             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nnn))
1764                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nnn))),
1765             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nop))
1766                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nop))),
1767             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(not))
1768                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(not))),
1769             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(note__nR))
1770                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(note__nR))),
1771             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nrot))
1772                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nrot))),
1773             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ogetbt))
1774                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetbt))),
1775             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ogetm))
1776                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetm))),
1777             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ogetu))
1778                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetu))),
1779             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(open))
1780                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(open))),
1781             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(or))
1782                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(or))),
1783             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(osetm))
1784                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(osetm))),
1785             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(over))
1786                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(over))),
1787             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pec))
1788                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pec))),
1789             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdi__nR))
1790                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdi__nR))),
1791             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdiu__nR))
1792                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdiu__nR))),
1793             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdl__nR))
1794                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdl__nR))),
1795             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekdlu__nR))
1796                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdlu__nR))),
1797             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peeki__nR__nR__nR))
1798                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeki__nR__nR__nR))),
1799             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekiu__nR__nR))
1800                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekiu__nR__nR))),
1801             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peekl__nR__nR__nR))
1802                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekl__nR__nR__nR))),
1803             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peeklu__nR__nR))
1804                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeklu__nR__nR))),
1805             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(peeks))
1806                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeks))),
1807             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokedi__nR))
1808                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedi__nR))),
1809             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokediu__nR))
1810                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokediu__nR))),
1811             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokedl__nR))
1812                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedl__nR))),
1813             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokedlu__nR))
1814                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedlu__nR))),
1815             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokei__nR__nR__nR))
1816                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokei__nR__nR__nR))),
1817             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokeiu__nR__nR))
1818                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokeiu__nR__nR))),
1819             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokel__nR__nR__nR))
1820                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokel__nR__nR__nR))),
1821             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokelu__nR__nR))
1822                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokelu__nR__nR))),
1823             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pokes))
1824                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokes))),
1825             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pope))
1826                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pope))),
1827             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popend))
1828                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popend))),
1829             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popf__nR))
1830                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popf__nR))),
1831             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popios))
1832                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popios))),
1833             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoac))
1834                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoac))),
1835             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popob))
1836                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popob))),
1837             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popobc))
1838                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popobc))),
1839             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoc))
1840                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoc))),
1841             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popod))
1842                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popod))),
1843             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoi))
1844                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoi))),
1845             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popom))
1846                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popom))),
1847             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popoo))
1848                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoo))),
1849             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popopp))
1850                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popopp))),
1851             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popr___rrR))
1852                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popr___rrR))),
1853             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(popvar__nR__nR))
1854                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popvar__nR__nR))),
1855             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powi))
1856                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powi))),
1857             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powiu))
1858                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powiu))),
1859             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powl))
1860                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powl))),
1861             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(powlu))
1862                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powlu))),
1863             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printi__nR))
1864                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printi__nR))),
1865             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printiu__nR))
1866                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printiu__nR))),
1867             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printl__nR))
1868                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printl__nR))),
1869             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(printlu__nR))
1870                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printlu__nR))),
1871             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(prints))
1872                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(prints))),
1873             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(prolog))
1874                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(prolog))),
1875             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push__nR))
1876                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push__nR))),
1877             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push__lR))
1878                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push__lR))),
1879             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push32__nR))
1880                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push32__nR))),
1881             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push32__lR))
1882                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push32__lR))),
1883             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushe__lR))
1884                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushe__lR))),
1885             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushend))
1886                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushend))),
1887             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushf__nR))
1888                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushf__nR))),
1889             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushhi__nR))
1890                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushhi__nR))),
1891             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushhi__lR))
1892                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushhi__lR))),
1893             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushios))
1894                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushios))),
1895             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushlo__nR))
1896                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushlo__nR))),
1897             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushlo__lR))
1898                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushlo__lR))),
1899             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoac))
1900                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoac))),
1901             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushob))
1902                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushob))),
1903             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushobc))
1904                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushobc))),
1905             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoc))
1906                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoc))),
1907             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushod))
1908                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushod))),
1909             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoi))
1910                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoi))),
1911             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushom))
1912                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushom))),
1913             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushoo))
1914                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoo))),
1915             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushopp))
1916                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushopp))),
1917             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushr___rrR))
1918                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushr___rrR))),
1919             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushtopvar__nR))
1920                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushtopvar__nR))),
1921             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n0))
1922                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n0))),
1923             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n1))
1924                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n1))),
1925             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n2))
1926                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n2))),
1927             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n3))
1928                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n3))),
1929             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n4))
1930                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n4))),
1931             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__n5))
1932                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n5))),
1933             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__n0__nR))
1934                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__nR))),
1935             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n0))
1936                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n0))),
1937             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n1))
1938                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n1))),
1939             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n2))
1940                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n2))),
1941             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n3))
1942                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n3))),
1943             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n4))
1944                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n4))),
1945             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__n5))
1946                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n5))),
1947             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pushvar__nR__nR))
1948                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__nR))),
1949             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(quake))
1950                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(quake))),
1951             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(raise))
1952                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(raise))),
1953             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(rand))
1954                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(rand))),
1955             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(regvar))
1956                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(regvar))),
1957             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(reloc))
1958                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(reloc))),
1959             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(restorer___rrR))
1960                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(restorer___rrR))),
1961             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(return))
1962                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(return))),
1963             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(revn__n3))
1964                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__n3))),
1965             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(revn__n4))
1966                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__n4))),
1967             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(revn__nR))
1968                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__nR))),
1969             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(rot))
1970                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(rot))),
1971             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(saver___rrR))
1972                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(saver___rrR))),
1973             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sconc))
1974                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sconc))),
1975             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sel))
1976                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sel))),
1977             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(setr___rrR))
1978                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(setr___rrR))),
1979             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(siz))
1980                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(siz))),
1981             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(smodi))
1982                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(smodi))),
1983             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sref))
1984                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sref))),
1985             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefi))
1986                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefi))),
1987             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefia))
1988                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefia))),
1989             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefio))
1990                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefio))),
1991             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefmnt))
1992                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefmnt))),
1993             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefnt))
1994                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefnt))),
1995             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(srefo))
1996                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefo))),
1997             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sset))
1998                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sset))),
1999             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(strace__nR))
2000                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(strace__nR))),
2001             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(strref))
2002                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(strref))),
2003             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(subi))
2004                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subi))),
2005             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(subiu))
2006                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subiu))),
2007             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(subl))
2008                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subl))),
2009             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sublu))
2010                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sublu))),
2011             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(substr))
2012                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(substr))),
2013             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swap))
2014                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swap))),
2015             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgti))
2016                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgti))),
2017             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgtiu))
2018                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtiu))),
2019             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgtl))
2020                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtl))),
2021             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(swapgtlu))
2022                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtlu))),
2023             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(sync))
2024                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sync))),
2025             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(time))
2026                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(time))),
2027             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tor))
2028                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tor))),
2029             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tuck))
2030                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tuck))),
2031             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyagetb))
2032                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyagetb))),
2033             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyagett))
2034                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyagett))),
2035             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyisc))
2036                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyisc))),
2037             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tyissct))
2038                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyissct))),
2039             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(typof))
2040                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(typof))),
2041             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tysctn))
2042                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tysctn))),
2043             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(unmap))
2044                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unmap))),
2045             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(unreachable))
2046                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unreachable))),
2047             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(ureloc))
2048                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ureloc))),
2049             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(write__retR))
2050                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(write__retR))),
2051             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aba__fR_A_mno_mfast_mbranches))
2052                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aba__fR_A_mno_mfast_mbranches))),
2053             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abn__fR_A_mno_mfast_mbranches))
2054                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abn__fR_A_mno_mfast_mbranches))),
2055             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnn__fR_A_mno_mfast_mbranches))
2056                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnn__fR_A_mno_mfast_mbranches))),
2057             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnzi__fR_A_mno_mfast_mbranches))
2058                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzi__fR_A_mno_mfast_mbranches))),
2059             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnziu__fR_A_mno_mfast_mbranches))
2060                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnziu__fR_A_mno_mfast_mbranches))),
2061             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnzl__fR_A_mno_mfast_mbranches))
2062                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzl__fR_A_mno_mfast_mbranches))),
2063             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abnzlu__fR_A_mno_mfast_mbranches))
2064                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzlu__fR_A_mno_mfast_mbranches))),
2065             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abzi__fR_A_mno_mfast_mbranches))
2066                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzi__fR_A_mno_mfast_mbranches))),
2067             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abziu__fR_A_mno_mfast_mbranches))
2068                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abziu__fR_A_mno_mfast_mbranches))),
2069             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abzl__fR_A_mno_mfast_mbranches))
2070                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzl__fR_A_mno_mfast_mbranches))),
2071             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abzlu__fR_A_mno_mfast_mbranches))
2072                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzlu__fR_A_mno_mfast_mbranches)))
2073           };
2074       pvm_thread_sizes = pvm_the_thread_sizes;
2075       pvm_threads = pvm_the_threads;
2076       pvm_thread_ends = pvm_the_thread_ends;
2077 #ifdef JITTER_PROFILE
2078       fprintf (stderr, "VM instruction range: ");
2079       fprintf (stderr, "[%p, ", && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID));
2080       fprintf (stderr, "%p)", && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abzlu__fR_A_mno_mfast_mbranches));
2081       fprintf (stderr, "\n");
2082 #endif // #ifdef JITTER_PROFILE
2083 #endif // #ifndef JITTER_DISPATCH_SWITCH
2084 
2085       /* Back to regular C, without our reserved registers if any; I can share
2086          the end code with the non-initialization case. */
2087 #ifdef JITTER_HAVE_PATCH_IN
2088       //JITTER_DUMP_PATCH_IN_DESCRIPTORS(pvm);
2089 #endif // #ifdef JITTER_HAVE_PATCH_IN
2090       goto jitter_possibly_restore_registers_and_return_label;
2091     }
2092 
2093 
2094   /* Here is the actual *executor* initialization, to be run before
2095      actually running the code. */
2096 
2097 /* Selectively suppress suprious -Wmaybe-uninitialized .
2098    The indirect jump hack I use in profiling mode in order to
2099    have a large gap inside a function introduced by assembler without
2100    being restricted by jump offset limits (intentionally) tricks GCC
2101    into believing that the indirect jump may reach any instruction label;
2102    GCC would then warn that some locals might be used uninitialized,
2103    by skipping over their initialization.  This however is not possible,
2104    and I want to selectively silence the warning for the variables in
2105    question. */
2106 #pragma GCC diagnostic push
2107 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
2108 
2109   /* Wrap functions and globals used within VM instructions, if needed.
2110      This is a trick to keep instructions readable while avoiding PC-relative
2111      addressing, which would mess up replicated code. */
2112 #ifdef JITTER_REPLICATE
2113 
2114   /* Protect the C globals used in VM instructions so that they are always
2115      referred thru a pointer (from a register or the stack) set in the
2116      non-replicated part.  This is necessary on architectures where I can't
2117      force global references to pass thru a GOT.
2118      [FIXME: possibly don't do this on architectures that don't need it.] */
2119 
2120   typeof (pvm_states) * volatile _my_volatile_pointer_to_pvm_states = & pvm_states;
2121   typeof (pvm_states) * const restrict _my_pointer_to_pvm_states __attribute__ ((unused))
2122      = _my_volatile_pointer_to_pvm_states;
2123 # undef pvm_states
2124 # define pvm_states (* _my_pointer_to_pvm_states)
2125 
2126   /* Similarly, wrap the C functions used in VM instructions, so that they are
2127      always called thru a function pointer.  This is necessary on architectures
2128      where call instructions represent the callee as a PC-relative address.
2129      Unfortunately C has a special quirky syntax for function pointers, so I
2130      can't just use the code above.  [FIXME: don't do this on architectures
2131      that don't need it.] */
2132   typeof (gettime) * volatile _my_volatile_pointer_to_gettime = & gettime;
2133   typeof (gettime) * const _my_gettime __attribute__ ((unused))
2134      = * _my_volatile_pointer_to_gettime;
2135 # undef gettime
2136 # define gettime _my_gettime
2137 
2138   typeof (secure_getenv) * volatile _my_volatile_pointer_to_secure_getenv = & secure_getenv;
2139   typeof (secure_getenv) * const _my_secure_getenv __attribute__ ((unused))
2140      = * _my_volatile_pointer_to_secure_getenv;
2141 # undef secure_getenv
2142 # define secure_getenv _my_secure_getenv
2143 
2144   typeof (srandom) * volatile _my_volatile_pointer_to_srandom = & srandom;
2145   typeof (srandom) * const _my_srandom __attribute__ ((unused))
2146      = * _my_volatile_pointer_to_srandom;
2147 # undef srandom
2148 # define srandom _my_srandom
2149 
2150   typeof (random) * volatile _my_volatile_pointer_to_random = & random;
2151   typeof (random) * const _my_random __attribute__ ((unused))
2152      = * _my_volatile_pointer_to_random;
2153 # undef random
2154 # define random _my_random
2155 
2156   typeof (ios_write_string) * volatile _my_volatile_pointer_to_ios_write_string = & ios_write_string;
2157   typeof (ios_write_string) * const _my_ios_write_string __attribute__ ((unused))
2158      = * _my_volatile_pointer_to_ios_write_string;
2159 # undef ios_write_string
2160 # define ios_write_string _my_ios_write_string
2161 
2162   typeof (ios_read_string) * volatile _my_volatile_pointer_to_ios_read_string = & ios_read_string;
2163   typeof (ios_read_string) * const _my_ios_read_string __attribute__ ((unused))
2164      = * _my_volatile_pointer_to_ios_read_string;
2165 # undef ios_read_string
2166 # define ios_read_string _my_ios_read_string
2167 
2168   typeof (ios_read_uint) * volatile _my_volatile_pointer_to_ios_read_uint = & ios_read_uint;
2169   typeof (ios_read_uint) * const _my_ios_read_uint __attribute__ ((unused))
2170      = * _my_volatile_pointer_to_ios_read_uint;
2171 # undef ios_read_uint
2172 # define ios_read_uint _my_ios_read_uint
2173 
2174   typeof (ios_read_int) * volatile _my_volatile_pointer_to_ios_read_int = & ios_read_int;
2175   typeof (ios_read_int) * const _my_ios_read_int __attribute__ ((unused))
2176      = * _my_volatile_pointer_to_ios_read_int;
2177 # undef ios_read_int
2178 # define ios_read_int _my_ios_read_int
2179 
2180   typeof (ios_cur) * volatile _my_volatile_pointer_to_ios_cur = & ios_cur;
2181   typeof (ios_cur) * const _my_ios_cur __attribute__ ((unused))
2182      = * _my_volatile_pointer_to_ios_cur;
2183 # undef ios_cur
2184 # define ios_cur _my_ios_cur
2185 
2186   typeof (pvm_val_ureloc) * volatile _my_volatile_pointer_to_pvm_val_ureloc = & pvm_val_ureloc;
2187   typeof (pvm_val_ureloc) * const _my_pvm_val_ureloc __attribute__ ((unused))
2188      = * _my_volatile_pointer_to_pvm_val_ureloc;
2189 # undef pvm_val_ureloc
2190 # define pvm_val_ureloc _my_pvm_val_ureloc
2191 
2192   typeof (pvm_val_unmap) * volatile _my_volatile_pointer_to_pvm_val_unmap = & pvm_val_unmap;
2193   typeof (pvm_val_unmap) * const _my_pvm_val_unmap __attribute__ ((unused))
2194      = * _my_volatile_pointer_to_pvm_val_unmap;
2195 # undef pvm_val_unmap
2196 # define pvm_val_unmap _my_pvm_val_unmap
2197 
2198   typeof (pvm_val_reloc) * volatile _my_volatile_pointer_to_pvm_val_reloc = & pvm_val_reloc;
2199   typeof (pvm_val_reloc) * const _my_pvm_val_reloc __attribute__ ((unused))
2200      = * _my_volatile_pointer_to_pvm_val_reloc;
2201 # undef pvm_val_reloc
2202 # define pvm_val_reloc _my_pvm_val_reloc
2203 
2204   typeof (pvm_set_struct) * volatile _my_volatile_pointer_to_pvm_set_struct = & pvm_set_struct;
2205   typeof (pvm_set_struct) * const _my_pvm_set_struct __attribute__ ((unused))
2206      = * _my_volatile_pointer_to_pvm_set_struct;
2207 # undef pvm_set_struct
2208 # define pvm_set_struct _my_pvm_set_struct
2209 
2210   typeof (pvm_ref_struct_cstr) * volatile _my_volatile_pointer_to_pvm_ref_struct_cstr = & pvm_ref_struct_cstr;
2211   typeof (pvm_ref_struct_cstr) * const _my_pvm_ref_struct_cstr __attribute__ ((unused))
2212      = * _my_volatile_pointer_to_pvm_ref_struct_cstr;
2213 # undef pvm_ref_struct_cstr
2214 # define pvm_ref_struct_cstr _my_pvm_ref_struct_cstr
2215 
2216   typeof (pvm_ref_struct) * volatile _my_volatile_pointer_to_pvm_ref_struct = & pvm_ref_struct;
2217   typeof (pvm_ref_struct) * const _my_pvm_ref_struct __attribute__ ((unused))
2218      = * _my_volatile_pointer_to_pvm_ref_struct;
2219 # undef pvm_ref_struct
2220 # define pvm_ref_struct _my_pvm_ref_struct
2221 
2222   typeof (pvm_type_equal_p) * volatile _my_volatile_pointer_to_pvm_type_equal_p = & pvm_type_equal_p;
2223   typeof (pvm_type_equal_p) * const _my_pvm_type_equal_p __attribute__ ((unused))
2224      = * _my_volatile_pointer_to_pvm_type_equal_p;
2225 # undef pvm_type_equal_p
2226 # define pvm_type_equal_p _my_pvm_type_equal_p
2227 
2228   typeof (pvm_typeof) * volatile _my_volatile_pointer_to_pvm_typeof = & pvm_typeof;
2229   typeof (pvm_typeof) * const _my_pvm_typeof __attribute__ ((unused))
2230      = * _my_volatile_pointer_to_pvm_typeof;
2231 # undef pvm_typeof
2232 # define pvm_typeof _my_pvm_typeof
2233 
2234   typeof (pvm_make_struct_type) * volatile _my_volatile_pointer_to_pvm_make_struct_type = & pvm_make_struct_type;
2235   typeof (pvm_make_struct_type) * const _my_pvm_make_struct_type __attribute__ ((unused))
2236      = * _my_volatile_pointer_to_pvm_make_struct_type;
2237 # undef pvm_make_struct_type
2238 # define pvm_make_struct_type _my_pvm_make_struct_type
2239 
2240   typeof (pvm_allocate_struct_attrs) * volatile _my_volatile_pointer_to_pvm_allocate_struct_attrs = & pvm_allocate_struct_attrs;
2241   typeof (pvm_allocate_struct_attrs) * const _my_pvm_allocate_struct_attrs __attribute__ ((unused))
2242      = * _my_volatile_pointer_to_pvm_allocate_struct_attrs;
2243 # undef pvm_allocate_struct_attrs
2244 # define pvm_allocate_struct_attrs _my_pvm_allocate_struct_attrs
2245 
2246   typeof (pvm_make_array_type) * volatile _my_volatile_pointer_to_pvm_make_array_type = & pvm_make_array_type;
2247   typeof (pvm_make_array_type) * const _my_pvm_make_array_type __attribute__ ((unused))
2248      = * _my_volatile_pointer_to_pvm_make_array_type;
2249 # undef pvm_make_array_type
2250 # define pvm_make_array_type _my_pvm_make_array_type
2251 
2252   typeof (pvm_make_offset_type) * volatile _my_volatile_pointer_to_pvm_make_offset_type = & pvm_make_offset_type;
2253   typeof (pvm_make_offset_type) * const _my_pvm_make_offset_type __attribute__ ((unused))
2254      = * _my_volatile_pointer_to_pvm_make_offset_type;
2255 # undef pvm_make_offset_type
2256 # define pvm_make_offset_type _my_pvm_make_offset_type
2257 
2258   typeof (pvm_make_string_type) * volatile _my_volatile_pointer_to_pvm_make_string_type = & pvm_make_string_type;
2259   typeof (pvm_make_string_type) * const _my_pvm_make_string_type __attribute__ ((unused))
2260      = * _my_volatile_pointer_to_pvm_make_string_type;
2261 # undef pvm_make_string_type
2262 # define pvm_make_string_type _my_pvm_make_string_type
2263 
2264   typeof (pvm_make_integral_type) * volatile _my_volatile_pointer_to_pvm_make_integral_type = & pvm_make_integral_type;
2265   typeof (pvm_make_integral_type) * const _my_pvm_make_integral_type __attribute__ ((unused))
2266      = * _my_volatile_pointer_to_pvm_make_integral_type;
2267 # undef pvm_make_integral_type
2268 # define pvm_make_integral_type _my_pvm_make_integral_type
2269 
2270   typeof (pvm_make_offset) * volatile _my_volatile_pointer_to_pvm_make_offset = & pvm_make_offset;
2271   typeof (pvm_make_offset) * const _my_pvm_make_offset __attribute__ ((unused))
2272      = * _my_volatile_pointer_to_pvm_make_offset;
2273 # undef pvm_make_offset
2274 # define pvm_make_offset _my_pvm_make_offset
2275 
2276   typeof (pvm_make_struct) * volatile _my_volatile_pointer_to_pvm_make_struct = & pvm_make_struct;
2277   typeof (pvm_make_struct) * const _my_pvm_make_struct __attribute__ ((unused))
2278      = * _my_volatile_pointer_to_pvm_make_struct;
2279 # undef pvm_make_struct
2280 # define pvm_make_struct _my_pvm_make_struct
2281 
2282   typeof (pvm_make_array) * volatile _my_volatile_pointer_to_pvm_make_array = & pvm_make_array;
2283   typeof (pvm_make_array) * const _my_pvm_make_array __attribute__ ((unused))
2284      = * _my_volatile_pointer_to_pvm_make_array;
2285 # undef pvm_make_array
2286 # define pvm_make_array _my_pvm_make_array
2287 
2288   typeof (pvm_make_string) * volatile _my_volatile_pointer_to_pvm_make_string = & pvm_make_string;
2289   typeof (pvm_make_string) * const _my_pvm_make_string __attribute__ ((unused))
2290      = * _my_volatile_pointer_to_pvm_make_string;
2291 # undef pvm_make_string
2292 # define pvm_make_string _my_pvm_make_string
2293 
2294   typeof (pvm_env_toplevel) * volatile _my_volatile_pointer_to_pvm_env_toplevel = & pvm_env_toplevel;
2295   typeof (pvm_env_toplevel) * const _my_pvm_env_toplevel __attribute__ ((unused))
2296      = * _my_volatile_pointer_to_pvm_env_toplevel;
2297 # undef pvm_env_toplevel
2298 # define pvm_env_toplevel _my_pvm_env_toplevel
2299 
2300   typeof (pvm_env_push_frame) * volatile _my_volatile_pointer_to_pvm_env_push_frame = & pvm_env_push_frame;
2301   typeof (pvm_env_push_frame) * const _my_pvm_env_push_frame __attribute__ ((unused))
2302      = * _my_volatile_pointer_to_pvm_env_push_frame;
2303 # undef pvm_env_push_frame
2304 # define pvm_env_push_frame _my_pvm_env_push_frame
2305 
2306   typeof (pvm_env_pop_frame) * volatile _my_volatile_pointer_to_pvm_env_pop_frame = & pvm_env_pop_frame;
2307   typeof (pvm_env_pop_frame) * const _my_pvm_env_pop_frame __attribute__ ((unused))
2308      = * _my_volatile_pointer_to_pvm_env_pop_frame;
2309 # undef pvm_env_pop_frame
2310 # define pvm_env_pop_frame _my_pvm_env_pop_frame
2311 
2312   typeof (pvm_env_register) * volatile _my_volatile_pointer_to_pvm_env_register = & pvm_env_register;
2313   typeof (pvm_env_register) * const _my_pvm_env_register __attribute__ ((unused))
2314      = * _my_volatile_pointer_to_pvm_env_register;
2315 # undef pvm_env_register
2316 # define pvm_env_register _my_pvm_env_register
2317 
2318   typeof (pvm_env_lookup) * volatile _my_volatile_pointer_to_pvm_env_lookup = & pvm_env_lookup;
2319   typeof (pvm_env_lookup) * const _my_pvm_env_lookup __attribute__ ((unused))
2320      = * _my_volatile_pointer_to_pvm_env_lookup;
2321 # undef pvm_env_lookup
2322 # define pvm_env_lookup _my_pvm_env_lookup
2323 
2324   typeof (pvm_assert) * volatile _my_volatile_pointer_to_pvm_assert = & pvm_assert;
2325   typeof (pvm_assert) * const _my_pvm_assert __attribute__ ((unused))
2326      = * _my_volatile_pointer_to_pvm_assert;
2327 # undef pvm_assert
2328 # define pvm_assert _my_pvm_assert
2329 
2330   typeof (pvm_array_set) * volatile _my_volatile_pointer_to_pvm_array_set = & pvm_array_set;
2331   typeof (pvm_array_set) * const _my_pvm_array_set __attribute__ ((unused))
2332      = * _my_volatile_pointer_to_pvm_array_set;
2333 # undef pvm_array_set
2334 # define pvm_array_set _my_pvm_array_set
2335 
2336   typeof (pvm_array_insert) * volatile _my_volatile_pointer_to_pvm_array_insert = & pvm_array_insert;
2337   typeof (pvm_array_insert) * const _my_pvm_array_insert __attribute__ ((unused))
2338      = * _my_volatile_pointer_to_pvm_array_insert;
2339 # undef pvm_array_insert
2340 # define pvm_array_insert _my_pvm_array_insert
2341 
2342   typeof (printf) * volatile _my_volatile_pointer_to_printf = & printf;
2343   typeof (printf) * const _my_printf __attribute__ ((unused))
2344      = * _my_volatile_pointer_to_printf;
2345 # undef printf
2346 # define printf _my_printf
2347 
2348   typeof (pk_printf) * volatile _my_volatile_pointer_to_pk_printf = & pk_printf;
2349   typeof (pk_printf) * const _my_pk_printf __attribute__ ((unused))
2350      = * _my_volatile_pointer_to_pk_printf;
2351 # undef pk_printf
2352 # define pk_printf _my_pk_printf
2353 
2354   typeof (pk_term_end_class) * volatile _my_volatile_pointer_to_pk_term_end_class = & pk_term_end_class;
2355   typeof (pk_term_end_class) * const _my_pk_term_end_class __attribute__ ((unused))
2356      = * _my_volatile_pointer_to_pk_term_end_class;
2357 # undef pk_term_end_class
2358 # define pk_term_end_class _my_pk_term_end_class
2359 
2360   typeof (pk_term_class) * volatile _my_volatile_pointer_to_pk_term_class = & pk_term_class;
2361   typeof (pk_term_class) * const _my_pk_term_class __attribute__ ((unused))
2362      = * _my_volatile_pointer_to_pk_term_class;
2363 # undef pk_term_class
2364 # define pk_term_class _my_pk_term_class
2365 
2366 /* See the comment above about spurious -Wmaybe-uninitialized warnings. */
2367 #pragma GCC diagnostic pop
2368 #endif // #ifdef JITTER_REPLICATE
2369 
2370 
2371   /* Make an automatic struct holding a copy of the state whose pointer was given.
2372      The idea is that the copy should be in registers, as far as possible. */
2373   struct pvm_state_runtime jitter_state_runtime
2374     = jitter_original_state->pvm_state_runtime;
2375 
2376   /* Initialize a pointer to The Array base.  This pointer will be in a
2377      global register variable with no-threading dispatch, and with
2378      other dispatches in an automatic variable, still hopefully kept
2379      in a register. */
2380 /* About the pragma, look for "-Wmaybe-uninitialized" in the comments above. FIXME: this is to avoid a GCC warning with profiling.  Check with profiling on. */
2381 #pragma GCC diagnostic push
2382 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
2383 #ifdef JITTER_DISPATCH_NO_THREADING
2384 # define jitter_array_base pvm_array_base_register_variable
2385 #else
2386   char * restrict jitter_array_base __attribute__ ((unused));
2387 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
2388 #pragma GCC diagnostic pop
2389   jitter_array_base
2390     = (((char *) jitter_original_state->pvm_state_backing.jitter_array)
2391        + JITTER_ARRAY_BIAS);
2392 
2393   /* Declare the instruction pointer from the thread array, unless the dispatching
2394      model is no-threading, in which case no thread array even exists. */
2395   pvm_program_point jitter_ip = NULL; /* Invalidate to catch errors. */
2396   /* Save an instruction address within this function, to jump to at VM exit
2397      time; that way we can be sure that at exit time we are back to
2398      non-replicated code, and stuff like PC-relative addressing work again
2399      without special tricks.  This variable may safely (and actually should,
2400      for performance) be kept on the stack.  We need it to be volatile to
2401      prevent the compiler from being too clever and jump to it using a
2402      PC-relative displacement from replicated code.   It must not be static,
2403      since non-automatic variables are problematic to access from replicated
2404      code, which might use PC-relative addressing. */
2405   volatile typeof (&& jitter_exit_vm_label) restrict
2406   jitter_saved_exit_non_replicated_code_pointer = &&jitter_exit_vm_label;
2407   JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(jitter_saved_exit_non_replicated_code_pointer);
2408 
2409 
2410 #ifdef JITTER_REPLICATE
2411   /* FIXME: comment. */
2412   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aba__fR_A_mno_mfast_mbranches)
2413     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aba__fR_A_mno_mfast_mbranches);
2414   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aba__fR_A_mno_mfast_mbranches)) "\n"
2415                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aba__fR_A_mno_mfast_mbranches)));
2416   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abn__fR_A_mno_mfast_mbranches)
2417     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abn__fR_A_mno_mfast_mbranches);
2418   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abn__fR_A_mno_mfast_mbranches)) "\n"
2419                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abn__fR_A_mno_mfast_mbranches)));
2420   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnn__fR_A_mno_mfast_mbranches)
2421     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abnn__fR_A_mno_mfast_mbranches);
2422   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnn__fR_A_mno_mfast_mbranches)) "\n"
2423                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnn__fR_A_mno_mfast_mbranches)));
2424   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzi__fR_A_mno_mfast_mbranches)
2425     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abnzi__fR_A_mno_mfast_mbranches);
2426   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzi__fR_A_mno_mfast_mbranches)) "\n"
2427                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzi__fR_A_mno_mfast_mbranches)));
2428   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnziu__fR_A_mno_mfast_mbranches)
2429     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abnziu__fR_A_mno_mfast_mbranches);
2430   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnziu__fR_A_mno_mfast_mbranches)) "\n"
2431                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnziu__fR_A_mno_mfast_mbranches)));
2432   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzl__fR_A_mno_mfast_mbranches)
2433     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abnzl__fR_A_mno_mfast_mbranches);
2434   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzl__fR_A_mno_mfast_mbranches)) "\n"
2435                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzl__fR_A_mno_mfast_mbranches)));
2436   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzlu__fR_A_mno_mfast_mbranches)
2437     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abnzlu__fR_A_mno_mfast_mbranches);
2438   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzlu__fR_A_mno_mfast_mbranches)) "\n"
2439                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abnzlu__fR_A_mno_mfast_mbranches)));
2440   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzi__fR_A_mno_mfast_mbranches)
2441     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abzi__fR_A_mno_mfast_mbranches);
2442   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzi__fR_A_mno_mfast_mbranches)) "\n"
2443                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzi__fR_A_mno_mfast_mbranches)));
2444   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abziu__fR_A_mno_mfast_mbranches)
2445     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abziu__fR_A_mno_mfast_mbranches);
2446   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abziu__fR_A_mno_mfast_mbranches)) "\n"
2447                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abziu__fR_A_mno_mfast_mbranches)));
2448   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzl__fR_A_mno_mfast_mbranches)
2449     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abzl__fR_A_mno_mfast_mbranches);
2450   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzl__fR_A_mno_mfast_mbranches)) "\n"
2451                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzl__fR_A_mno_mfast_mbranches)));
2452   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzlu__fR_A_mno_mfast_mbranches)
2453     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abzlu__fR_A_mno_mfast_mbranches);
2454   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzlu__fR_A_mno_mfast_mbranches)) "\n"
2455                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abzlu__fR_A_mno_mfast_mbranches)));
2456 #endif // #ifdef JITTER_REPLICATE
2457   /* Initialization C code from the user */
2458   /* End of the initialization C code from the user */
2459 
2460 
2461   /* Execute architecture-specific execution-beginning code, if any.
2462      Make sure it is safe to expand the macro without do..while
2463      (false). */
2464   {}; JITTER_EXECUTION_BEGINNING_; {};
2465 
2466 #if defined (JITTER_PROFILE_SAMPLE)
2467     /* Start sample-profiling: this starts the periodic timer signal,
2468        whose handler will look at the current instruction field within
2469        the special-purpose struct in the Array. */
2470     pvm_profile_sample_start (PVM_OWN_STATE);
2471 #endif // #if defined (JITTER_PROFILE_SAMPLE)
2472 
2473   /* Jump to the first instruction.  If replication is enabled this point
2474      marks the boundary between the ordinary world of C compiled code and
2475      the more fragile replicated code, where PC-relative address does
2476      not work as intended (which prevents the use of global and static
2477      variables, string literals and possibly large literal constants), and
2478      GDB gets easily confused. */
2479   jitter_ip = jitter_initial_program_point;
2480 
2481   /* This is the actual jump to the first instruction: it's not an
2482      inline asm constraint lie like below. */
2483 
2484 # if   defined(JITTER_DISPATCH_SWITCH)
2485     goto jitter_dispatching_switch_label;
2486 # elif (defined(JITTER_DISPATCH_DIRECT_THREADING)  \
2487         || defined(JITTER_DISPATCH_MINIMAL_THREADING))
2488     goto * (jitter_ip->label);
2489 # elif defined(JITTER_DISPATCH_NO_THREADING)
2490     /* On no-threading we only use jitter_ip for the first instruction.
2491        Make it an alias for the base, which will be enough to satisfy
2492        inline assembly code which pretends to alter the instruction
2493        pointer in ways invisible to the compiler.
2494        At least in my tests this trick frees up one hardware register,
2495        which is not surprising. */
2496     goto * jitter_ip;
2497 #   define jitter_ip pvm_array_base_register_variable
2498 # else
2499 #   error "unknown dispatch"
2500 # endif // if ... dispatch
2501   /* FIXME: comment: this is the fake dispatch routine. */
2502  /* The label is unused (from the compiler's point of view) for simple
2503     dispatches when not profiling.  (In reality it is always unused.)
2504     FIXME: comment. */
2505  jitter_dispatch_label: __attribute__ ((hot, unused))
2506 #if   defined(JITTER_DISPATCH_SWITCH)
2507   /* This code is unreachable, but the compiler does not know it.  FIXME: comment. */
2508   goto jitter_dispatching_switch_label;
2509 #elif defined(JITTER_DISPATCH_DIRECT_THREADING)
2510   /* Again this code is unreachable, but the compiler does not know it.  FIXME: comment. */
2511   goto * jitter_ip;
2512 #endif
2513 #ifdef JITTER_REPLICATE
2514   asm volatile ("\njitter_dispatch_label_asm:\n" :);
2515   JITTER_PRETEND_TO_UPDATE_IP_;
2516   JITTER_PRETEND_TO_UPDATE_IP_;
2517   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID));
2518   JITTER_PRETEND_TO_UPDATE_IP_;
2519   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eBEGINBASICBLOCK));
2520   JITTER_PRETEND_TO_UPDATE_IP_;
2521   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eEXITVM));
2522   JITTER_PRETEND_TO_UPDATE_IP_;
2523   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eDATALOCATIONS));
2524   JITTER_PRETEND_TO_UPDATE_IP_;
2525   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eNOP));
2526   JITTER_PRETEND_TO_UPDATE_IP_;
2527   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE0));
2528   JITTER_PRETEND_TO_UPDATE_IP_;
2529   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE1));
2530   JITTER_PRETEND_TO_UPDATE_IP_;
2531   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE2));
2532   JITTER_PRETEND_TO_UPDATE_IP_;
2533   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addi));
2534   JITTER_PRETEND_TO_UPDATE_IP_;
2535   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addiu));
2536   JITTER_PRETEND_TO_UPDATE_IP_;
2537   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addl));
2538   JITTER_PRETEND_TO_UPDATE_IP_;
2539   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(addlu));
2540   JITTER_PRETEND_TO_UPDATE_IP_;
2541   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ains));
2542   JITTER_PRETEND_TO_UPDATE_IP_;
2543   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(and));
2544   JITTER_PRETEND_TO_UPDATE_IP_;
2545   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(aref));
2546   JITTER_PRETEND_TO_UPDATE_IP_;
2547   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(arefo));
2548   JITTER_PRETEND_TO_UPDATE_IP_;
2549   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(arem));
2550   JITTER_PRETEND_TO_UPDATE_IP_;
2551   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(aset));
2552   JITTER_PRETEND_TO_UPDATE_IP_;
2553   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(asettb));
2554   JITTER_PRETEND_TO_UPDATE_IP_;
2555   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(atr));
2556   JITTER_PRETEND_TO_UPDATE_IP_;
2557   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ba__fR));
2558   JITTER_PRETEND_TO_UPDATE_IP_;
2559   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandi));
2560   JITTER_PRETEND_TO_UPDATE_IP_;
2561   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandiu));
2562   JITTER_PRETEND_TO_UPDATE_IP_;
2563   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandl));
2564   JITTER_PRETEND_TO_UPDATE_IP_;
2565   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bandlu));
2566   JITTER_PRETEND_TO_UPDATE_IP_;
2567   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(beghl));
2568   JITTER_PRETEND_TO_UPDATE_IP_;
2569   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(begsc));
2570   JITTER_PRETEND_TO_UPDATE_IP_;
2571   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bn__fR));
2572   JITTER_PRETEND_TO_UPDATE_IP_;
2573   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnn__fR));
2574   JITTER_PRETEND_TO_UPDATE_IP_;
2575   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnoti));
2576   JITTER_PRETEND_TO_UPDATE_IP_;
2577   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotiu));
2578   JITTER_PRETEND_TO_UPDATE_IP_;
2579   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotl));
2580   JITTER_PRETEND_TO_UPDATE_IP_;
2581   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnotlu));
2582   JITTER_PRETEND_TO_UPDATE_IP_;
2583   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzi__fR));
2584   JITTER_PRETEND_TO_UPDATE_IP_;
2585   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnziu__fR));
2586   JITTER_PRETEND_TO_UPDATE_IP_;
2587   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzl__fR));
2588   JITTER_PRETEND_TO_UPDATE_IP_;
2589   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bnzlu__fR));
2590   JITTER_PRETEND_TO_UPDATE_IP_;
2591   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bori));
2592   JITTER_PRETEND_TO_UPDATE_IP_;
2593   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(boriu));
2594   JITTER_PRETEND_TO_UPDATE_IP_;
2595   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(borl));
2596   JITTER_PRETEND_TO_UPDATE_IP_;
2597   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(borlu));
2598   JITTER_PRETEND_TO_UPDATE_IP_;
2599   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsli));
2600   JITTER_PRETEND_TO_UPDATE_IP_;
2601   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsliu));
2602   JITTER_PRETEND_TO_UPDATE_IP_;
2603   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsll));
2604   JITTER_PRETEND_TO_UPDATE_IP_;
2605   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsllu));
2606   JITTER_PRETEND_TO_UPDATE_IP_;
2607   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsri));
2608   JITTER_PRETEND_TO_UPDATE_IP_;
2609   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsriu));
2610   JITTER_PRETEND_TO_UPDATE_IP_;
2611   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsrl));
2612   JITTER_PRETEND_TO_UPDATE_IP_;
2613   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bsrlu));
2614   JITTER_PRETEND_TO_UPDATE_IP_;
2615   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxori));
2616   JITTER_PRETEND_TO_UPDATE_IP_;
2617   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxoriu));
2618   JITTER_PRETEND_TO_UPDATE_IP_;
2619   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxorl));
2620   JITTER_PRETEND_TO_UPDATE_IP_;
2621   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bxorlu));
2622   JITTER_PRETEND_TO_UPDATE_IP_;
2623   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzi__fR));
2624   JITTER_PRETEND_TO_UPDATE_IP_;
2625   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bziu__fR));
2626   JITTER_PRETEND_TO_UPDATE_IP_;
2627   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzl__fR));
2628   JITTER_PRETEND_TO_UPDATE_IP_;
2629   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(bzlu__fR));
2630   JITTER_PRETEND_TO_UPDATE_IP_;
2631   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__retR));
2632   JITTER_PRETEND_TO_UPDATE_IP_;
2633   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(canary));
2634   JITTER_PRETEND_TO_UPDATE_IP_;
2635   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(close));
2636   JITTER_PRETEND_TO_UPDATE_IP_;
2637   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ctos));
2638   JITTER_PRETEND_TO_UPDATE_IP_;
2639   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(disas));
2640   JITTER_PRETEND_TO_UPDATE_IP_;
2641   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divi));
2642   JITTER_PRETEND_TO_UPDATE_IP_;
2643   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(diviu));
2644   JITTER_PRETEND_TO_UPDATE_IP_;
2645   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divl));
2646   JITTER_PRETEND_TO_UPDATE_IP_;
2647   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(divlu));
2648   JITTER_PRETEND_TO_UPDATE_IP_;
2649   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop));
2650   JITTER_PRETEND_TO_UPDATE_IP_;
2651   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop2));
2652   JITTER_PRETEND_TO_UPDATE_IP_;
2653   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop3));
2654   JITTER_PRETEND_TO_UPDATE_IP_;
2655   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop4));
2656   JITTER_PRETEND_TO_UPDATE_IP_;
2657   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(duc));
2658   JITTER_PRETEND_TO_UPDATE_IP_;
2659   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(dup));
2660   JITTER_PRETEND_TO_UPDATE_IP_;
2661   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(endhl));
2662   JITTER_PRETEND_TO_UPDATE_IP_;
2663   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(endsc));
2664   JITTER_PRETEND_TO_UPDATE_IP_;
2665   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqi));
2666   JITTER_PRETEND_TO_UPDATE_IP_;
2667   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqiu));
2668   JITTER_PRETEND_TO_UPDATE_IP_;
2669   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eql));
2670   JITTER_PRETEND_TO_UPDATE_IP_;
2671   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqlu));
2672   JITTER_PRETEND_TO_UPDATE_IP_;
2673   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(eqs));
2674   JITTER_PRETEND_TO_UPDATE_IP_;
2675   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exit));
2676   JITTER_PRETEND_TO_UPDATE_IP_;
2677   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exitvm));
2678   JITTER_PRETEND_TO_UPDATE_IP_;
2679   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(flush));
2680   JITTER_PRETEND_TO_UPDATE_IP_;
2681   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(fromr));
2682   JITTER_PRETEND_TO_UPDATE_IP_;
2683   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gei));
2684   JITTER_PRETEND_TO_UPDATE_IP_;
2685   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(geiu));
2686   JITTER_PRETEND_TO_UPDATE_IP_;
2687   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gel));
2688   JITTER_PRETEND_TO_UPDATE_IP_;
2689   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gelu));
2690   JITTER_PRETEND_TO_UPDATE_IP_;
2691   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ges));
2692   JITTER_PRETEND_TO_UPDATE_IP_;
2693   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(getenv));
2694   JITTER_PRETEND_TO_UPDATE_IP_;
2695   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gti));
2696   JITTER_PRETEND_TO_UPDATE_IP_;
2697   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtiu));
2698   JITTER_PRETEND_TO_UPDATE_IP_;
2699   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtl));
2700   JITTER_PRETEND_TO_UPDATE_IP_;
2701   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gtlu));
2702   JITTER_PRETEND_TO_UPDATE_IP_;
2703   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gts));
2704   JITTER_PRETEND_TO_UPDATE_IP_;
2705   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(indent));
2706   JITTER_PRETEND_TO_UPDATE_IP_;
2707   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iogetb));
2708   JITTER_PRETEND_TO_UPDATE_IP_;
2709   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iosetb));
2710   JITTER_PRETEND_TO_UPDATE_IP_;
2711   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iosize));
2712   JITTER_PRETEND_TO_UPDATE_IP_;
2713   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(isa));
2714   JITTER_PRETEND_TO_UPDATE_IP_;
2715   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itoi__nR));
2716   JITTER_PRETEND_TO_UPDATE_IP_;
2717   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itoiu__nR));
2718   JITTER_PRETEND_TO_UPDATE_IP_;
2719   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itol__nR));
2720   JITTER_PRETEND_TO_UPDATE_IP_;
2721   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(itolu__nR));
2722   JITTER_PRETEND_TO_UPDATE_IP_;
2723   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutoi__nR));
2724   JITTER_PRETEND_TO_UPDATE_IP_;
2725   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutoiu__nR));
2726   JITTER_PRETEND_TO_UPDATE_IP_;
2727   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutol__nR));
2728   JITTER_PRETEND_TO_UPDATE_IP_;
2729   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(iutolu__nR));
2730   JITTER_PRETEND_TO_UPDATE_IP_;
2731   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lei));
2732   JITTER_PRETEND_TO_UPDATE_IP_;
2733   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(leiu));
2734   JITTER_PRETEND_TO_UPDATE_IP_;
2735   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lel));
2736   JITTER_PRETEND_TO_UPDATE_IP_;
2737   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lelu));
2738   JITTER_PRETEND_TO_UPDATE_IP_;
2739   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(les));
2740   JITTER_PRETEND_TO_UPDATE_IP_;
2741   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lti));
2742   JITTER_PRETEND_TO_UPDATE_IP_;
2743   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltiu));
2744   JITTER_PRETEND_TO_UPDATE_IP_;
2745   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltl));
2746   JITTER_PRETEND_TO_UPDATE_IP_;
2747   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltlu));
2748   JITTER_PRETEND_TO_UPDATE_IP_;
2749   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltoi__nR));
2750   JITTER_PRETEND_TO_UPDATE_IP_;
2751   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltoiu__nR));
2752   JITTER_PRETEND_TO_UPDATE_IP_;
2753   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltol__nR));
2754   JITTER_PRETEND_TO_UPDATE_IP_;
2755   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ltolu__nR));
2756   JITTER_PRETEND_TO_UPDATE_IP_;
2757   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lts));
2758   JITTER_PRETEND_TO_UPDATE_IP_;
2759   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutoi__nR));
2760   JITTER_PRETEND_TO_UPDATE_IP_;
2761   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutoiu__nR));
2762   JITTER_PRETEND_TO_UPDATE_IP_;
2763   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutol__nR));
2764   JITTER_PRETEND_TO_UPDATE_IP_;
2765   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(lutolu__nR));
2766   JITTER_PRETEND_TO_UPDATE_IP_;
2767   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(map));
2768   JITTER_PRETEND_TO_UPDATE_IP_;
2769   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetios));
2770   JITTER_PRETEND_TO_UPDATE_IP_;
2771   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetm));
2772   JITTER_PRETEND_TO_UPDATE_IP_;
2773   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgeto));
2774   JITTER_PRETEND_TO_UPDATE_IP_;
2775   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgets));
2776   JITTER_PRETEND_TO_UPDATE_IP_;
2777   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetsel));
2778   JITTER_PRETEND_TO_UPDATE_IP_;
2779   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetsiz));
2780   JITTER_PRETEND_TO_UPDATE_IP_;
2781   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mgetw));
2782   JITTER_PRETEND_TO_UPDATE_IP_;
2783   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mka));
2784   JITTER_PRETEND_TO_UPDATE_IP_;
2785   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mko));
2786   JITTER_PRETEND_TO_UPDATE_IP_;
2787   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mksct));
2788   JITTER_PRETEND_TO_UPDATE_IP_;
2789   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktya));
2790   JITTER_PRETEND_TO_UPDATE_IP_;
2791   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyany));
2792   JITTER_PRETEND_TO_UPDATE_IP_;
2793   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyc));
2794   JITTER_PRETEND_TO_UPDATE_IP_;
2795   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyi));
2796   JITTER_PRETEND_TO_UPDATE_IP_;
2797   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyo));
2798   JITTER_PRETEND_TO_UPDATE_IP_;
2799   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktys));
2800   JITTER_PRETEND_TO_UPDATE_IP_;
2801   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktysct));
2802   JITTER_PRETEND_TO_UPDATE_IP_;
2803   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mktyv));
2804   JITTER_PRETEND_TO_UPDATE_IP_;
2805   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mm));
2806   JITTER_PRETEND_TO_UPDATE_IP_;
2807   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modi));
2808   JITTER_PRETEND_TO_UPDATE_IP_;
2809   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modiu));
2810   JITTER_PRETEND_TO_UPDATE_IP_;
2811   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modl));
2812   JITTER_PRETEND_TO_UPDATE_IP_;
2813   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(modlu));
2814   JITTER_PRETEND_TO_UPDATE_IP_;
2815   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetios));
2816   JITTER_PRETEND_TO_UPDATE_IP_;
2817   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetm));
2818   JITTER_PRETEND_TO_UPDATE_IP_;
2819   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mseto));
2820   JITTER_PRETEND_TO_UPDATE_IP_;
2821   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msets));
2822   JITTER_PRETEND_TO_UPDATE_IP_;
2823   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetsel));
2824   JITTER_PRETEND_TO_UPDATE_IP_;
2825   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetsiz));
2826   JITTER_PRETEND_TO_UPDATE_IP_;
2827   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(msetw));
2828   JITTER_PRETEND_TO_UPDATE_IP_;
2829   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muli));
2830   JITTER_PRETEND_TO_UPDATE_IP_;
2831   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muliu));
2832   JITTER_PRETEND_TO_UPDATE_IP_;
2833   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mull));
2834   JITTER_PRETEND_TO_UPDATE_IP_;
2835   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(mullu));
2836   JITTER_PRETEND_TO_UPDATE_IP_;
2837   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(muls));
2838   JITTER_PRETEND_TO_UPDATE_IP_;
2839   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negi));
2840   JITTER_PRETEND_TO_UPDATE_IP_;
2841   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negiu));
2842   JITTER_PRETEND_TO_UPDATE_IP_;
2843   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(negl));
2844   JITTER_PRETEND_TO_UPDATE_IP_;
2845   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(neglu));
2846   JITTER_PRETEND_TO_UPDATE_IP_;
2847   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nei));
2848   JITTER_PRETEND_TO_UPDATE_IP_;
2849   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(neiu));
2850   JITTER_PRETEND_TO_UPDATE_IP_;
2851   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nel));
2852   JITTER_PRETEND_TO_UPDATE_IP_;
2853   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nelu));
2854   JITTER_PRETEND_TO_UPDATE_IP_;
2855   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nes));
2856   JITTER_PRETEND_TO_UPDATE_IP_;
2857   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip));
2858   JITTER_PRETEND_TO_UPDATE_IP_;
2859   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip2));
2860   JITTER_PRETEND_TO_UPDATE_IP_;
2861   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip3));
2862   JITTER_PRETEND_TO_UPDATE_IP_;
2863   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nn));
2864   JITTER_PRETEND_TO_UPDATE_IP_;
2865   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nnn));
2866   JITTER_PRETEND_TO_UPDATE_IP_;
2867   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nop));
2868   JITTER_PRETEND_TO_UPDATE_IP_;
2869   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(not));
2870   JITTER_PRETEND_TO_UPDATE_IP_;
2871   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(note__nR));
2872   JITTER_PRETEND_TO_UPDATE_IP_;
2873   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nrot));
2874   JITTER_PRETEND_TO_UPDATE_IP_;
2875   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetbt));
2876   JITTER_PRETEND_TO_UPDATE_IP_;
2877   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetm));
2878   JITTER_PRETEND_TO_UPDATE_IP_;
2879   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ogetu));
2880   JITTER_PRETEND_TO_UPDATE_IP_;
2881   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(open));
2882   JITTER_PRETEND_TO_UPDATE_IP_;
2883   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(or));
2884   JITTER_PRETEND_TO_UPDATE_IP_;
2885   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(osetm));
2886   JITTER_PRETEND_TO_UPDATE_IP_;
2887   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(over));
2888   JITTER_PRETEND_TO_UPDATE_IP_;
2889   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pec));
2890   JITTER_PRETEND_TO_UPDATE_IP_;
2891   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdi__nR));
2892   JITTER_PRETEND_TO_UPDATE_IP_;
2893   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdiu__nR));
2894   JITTER_PRETEND_TO_UPDATE_IP_;
2895   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdl__nR));
2896   JITTER_PRETEND_TO_UPDATE_IP_;
2897   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekdlu__nR));
2898   JITTER_PRETEND_TO_UPDATE_IP_;
2899   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeki__nR__nR__nR));
2900   JITTER_PRETEND_TO_UPDATE_IP_;
2901   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekiu__nR__nR));
2902   JITTER_PRETEND_TO_UPDATE_IP_;
2903   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peekl__nR__nR__nR));
2904   JITTER_PRETEND_TO_UPDATE_IP_;
2905   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeklu__nR__nR));
2906   JITTER_PRETEND_TO_UPDATE_IP_;
2907   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(peeks));
2908   JITTER_PRETEND_TO_UPDATE_IP_;
2909   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedi__nR));
2910   JITTER_PRETEND_TO_UPDATE_IP_;
2911   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokediu__nR));
2912   JITTER_PRETEND_TO_UPDATE_IP_;
2913   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedl__nR));
2914   JITTER_PRETEND_TO_UPDATE_IP_;
2915   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokedlu__nR));
2916   JITTER_PRETEND_TO_UPDATE_IP_;
2917   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokei__nR__nR__nR));
2918   JITTER_PRETEND_TO_UPDATE_IP_;
2919   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokeiu__nR__nR));
2920   JITTER_PRETEND_TO_UPDATE_IP_;
2921   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokel__nR__nR__nR));
2922   JITTER_PRETEND_TO_UPDATE_IP_;
2923   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokelu__nR__nR));
2924   JITTER_PRETEND_TO_UPDATE_IP_;
2925   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pokes));
2926   JITTER_PRETEND_TO_UPDATE_IP_;
2927   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pope));
2928   JITTER_PRETEND_TO_UPDATE_IP_;
2929   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popend));
2930   JITTER_PRETEND_TO_UPDATE_IP_;
2931   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popf__nR));
2932   JITTER_PRETEND_TO_UPDATE_IP_;
2933   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popios));
2934   JITTER_PRETEND_TO_UPDATE_IP_;
2935   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoac));
2936   JITTER_PRETEND_TO_UPDATE_IP_;
2937   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popob));
2938   JITTER_PRETEND_TO_UPDATE_IP_;
2939   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popobc));
2940   JITTER_PRETEND_TO_UPDATE_IP_;
2941   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoc));
2942   JITTER_PRETEND_TO_UPDATE_IP_;
2943   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popod));
2944   JITTER_PRETEND_TO_UPDATE_IP_;
2945   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoi));
2946   JITTER_PRETEND_TO_UPDATE_IP_;
2947   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popom));
2948   JITTER_PRETEND_TO_UPDATE_IP_;
2949   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popoo));
2950   JITTER_PRETEND_TO_UPDATE_IP_;
2951   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popopp));
2952   JITTER_PRETEND_TO_UPDATE_IP_;
2953   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popr___rrR));
2954   JITTER_PRETEND_TO_UPDATE_IP_;
2955   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(popvar__nR__nR));
2956   JITTER_PRETEND_TO_UPDATE_IP_;
2957   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powi));
2958   JITTER_PRETEND_TO_UPDATE_IP_;
2959   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powiu));
2960   JITTER_PRETEND_TO_UPDATE_IP_;
2961   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powl));
2962   JITTER_PRETEND_TO_UPDATE_IP_;
2963   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(powlu));
2964   JITTER_PRETEND_TO_UPDATE_IP_;
2965   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printi__nR));
2966   JITTER_PRETEND_TO_UPDATE_IP_;
2967   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printiu__nR));
2968   JITTER_PRETEND_TO_UPDATE_IP_;
2969   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printl__nR));
2970   JITTER_PRETEND_TO_UPDATE_IP_;
2971   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(printlu__nR));
2972   JITTER_PRETEND_TO_UPDATE_IP_;
2973   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(prints));
2974   JITTER_PRETEND_TO_UPDATE_IP_;
2975   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(prolog));
2976   JITTER_PRETEND_TO_UPDATE_IP_;
2977   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push__nR));
2978   JITTER_PRETEND_TO_UPDATE_IP_;
2979   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push__lR));
2980   JITTER_PRETEND_TO_UPDATE_IP_;
2981   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push32__nR));
2982   JITTER_PRETEND_TO_UPDATE_IP_;
2983   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push32__lR));
2984   JITTER_PRETEND_TO_UPDATE_IP_;
2985   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushe__lR));
2986   JITTER_PRETEND_TO_UPDATE_IP_;
2987   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushend));
2988   JITTER_PRETEND_TO_UPDATE_IP_;
2989   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushf__nR));
2990   JITTER_PRETEND_TO_UPDATE_IP_;
2991   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushhi__nR));
2992   JITTER_PRETEND_TO_UPDATE_IP_;
2993   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushhi__lR));
2994   JITTER_PRETEND_TO_UPDATE_IP_;
2995   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushios));
2996   JITTER_PRETEND_TO_UPDATE_IP_;
2997   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushlo__nR));
2998   JITTER_PRETEND_TO_UPDATE_IP_;
2999   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushlo__lR));
3000   JITTER_PRETEND_TO_UPDATE_IP_;
3001   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoac));
3002   JITTER_PRETEND_TO_UPDATE_IP_;
3003   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushob));
3004   JITTER_PRETEND_TO_UPDATE_IP_;
3005   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushobc));
3006   JITTER_PRETEND_TO_UPDATE_IP_;
3007   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoc));
3008   JITTER_PRETEND_TO_UPDATE_IP_;
3009   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushod));
3010   JITTER_PRETEND_TO_UPDATE_IP_;
3011   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoi));
3012   JITTER_PRETEND_TO_UPDATE_IP_;
3013   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushom));
3014   JITTER_PRETEND_TO_UPDATE_IP_;
3015   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushoo));
3016   JITTER_PRETEND_TO_UPDATE_IP_;
3017   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushopp));
3018   JITTER_PRETEND_TO_UPDATE_IP_;
3019   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushr___rrR));
3020   JITTER_PRETEND_TO_UPDATE_IP_;
3021   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushtopvar__nR));
3022   JITTER_PRETEND_TO_UPDATE_IP_;
3023   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n0));
3024   JITTER_PRETEND_TO_UPDATE_IP_;
3025   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n1));
3026   JITTER_PRETEND_TO_UPDATE_IP_;
3027   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n2));
3028   JITTER_PRETEND_TO_UPDATE_IP_;
3029   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n3));
3030   JITTER_PRETEND_TO_UPDATE_IP_;
3031   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n4));
3032   JITTER_PRETEND_TO_UPDATE_IP_;
3033   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__n5));
3034   JITTER_PRETEND_TO_UPDATE_IP_;
3035   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__n0__nR));
3036   JITTER_PRETEND_TO_UPDATE_IP_;
3037   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n0));
3038   JITTER_PRETEND_TO_UPDATE_IP_;
3039   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n1));
3040   JITTER_PRETEND_TO_UPDATE_IP_;
3041   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n2));
3042   JITTER_PRETEND_TO_UPDATE_IP_;
3043   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n3));
3044   JITTER_PRETEND_TO_UPDATE_IP_;
3045   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n4));
3046   JITTER_PRETEND_TO_UPDATE_IP_;
3047   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__n5));
3048   JITTER_PRETEND_TO_UPDATE_IP_;
3049   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pushvar__nR__nR));
3050   JITTER_PRETEND_TO_UPDATE_IP_;
3051   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(quake));
3052   JITTER_PRETEND_TO_UPDATE_IP_;
3053   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(raise));
3054   JITTER_PRETEND_TO_UPDATE_IP_;
3055   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(rand));
3056   JITTER_PRETEND_TO_UPDATE_IP_;
3057   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(regvar));
3058   JITTER_PRETEND_TO_UPDATE_IP_;
3059   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(reloc));
3060   JITTER_PRETEND_TO_UPDATE_IP_;
3061   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(restorer___rrR));
3062   JITTER_PRETEND_TO_UPDATE_IP_;
3063   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(return));
3064   JITTER_PRETEND_TO_UPDATE_IP_;
3065   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__n3));
3066   JITTER_PRETEND_TO_UPDATE_IP_;
3067   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__n4));
3068   JITTER_PRETEND_TO_UPDATE_IP_;
3069   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(revn__nR));
3070   JITTER_PRETEND_TO_UPDATE_IP_;
3071   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(rot));
3072   JITTER_PRETEND_TO_UPDATE_IP_;
3073   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(saver___rrR));
3074   JITTER_PRETEND_TO_UPDATE_IP_;
3075   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sconc));
3076   JITTER_PRETEND_TO_UPDATE_IP_;
3077   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sel));
3078   JITTER_PRETEND_TO_UPDATE_IP_;
3079   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(setr___rrR));
3080   JITTER_PRETEND_TO_UPDATE_IP_;
3081   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(siz));
3082   JITTER_PRETEND_TO_UPDATE_IP_;
3083   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(smodi));
3084   JITTER_PRETEND_TO_UPDATE_IP_;
3085   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sref));
3086   JITTER_PRETEND_TO_UPDATE_IP_;
3087   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefi));
3088   JITTER_PRETEND_TO_UPDATE_IP_;
3089   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefia));
3090   JITTER_PRETEND_TO_UPDATE_IP_;
3091   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefio));
3092   JITTER_PRETEND_TO_UPDATE_IP_;
3093   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefmnt));
3094   JITTER_PRETEND_TO_UPDATE_IP_;
3095   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefnt));
3096   JITTER_PRETEND_TO_UPDATE_IP_;
3097   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(srefo));
3098   JITTER_PRETEND_TO_UPDATE_IP_;
3099   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sset));
3100   JITTER_PRETEND_TO_UPDATE_IP_;
3101   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(strace__nR));
3102   JITTER_PRETEND_TO_UPDATE_IP_;
3103   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(strref));
3104   JITTER_PRETEND_TO_UPDATE_IP_;
3105   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subi));
3106   JITTER_PRETEND_TO_UPDATE_IP_;
3107   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subiu));
3108   JITTER_PRETEND_TO_UPDATE_IP_;
3109   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(subl));
3110   JITTER_PRETEND_TO_UPDATE_IP_;
3111   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sublu));
3112   JITTER_PRETEND_TO_UPDATE_IP_;
3113   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(substr));
3114   JITTER_PRETEND_TO_UPDATE_IP_;
3115   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swap));
3116   JITTER_PRETEND_TO_UPDATE_IP_;
3117   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgti));
3118   JITTER_PRETEND_TO_UPDATE_IP_;
3119   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtiu));
3120   JITTER_PRETEND_TO_UPDATE_IP_;
3121   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtl));
3122   JITTER_PRETEND_TO_UPDATE_IP_;
3123   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(swapgtlu));
3124   JITTER_PRETEND_TO_UPDATE_IP_;
3125   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(sync));
3126   JITTER_PRETEND_TO_UPDATE_IP_;
3127   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(time));
3128   JITTER_PRETEND_TO_UPDATE_IP_;
3129   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tor));
3130   JITTER_PRETEND_TO_UPDATE_IP_;
3131   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tuck));
3132   JITTER_PRETEND_TO_UPDATE_IP_;
3133   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyagetb));
3134   JITTER_PRETEND_TO_UPDATE_IP_;
3135   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyagett));
3136   JITTER_PRETEND_TO_UPDATE_IP_;
3137   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyisc));
3138   JITTER_PRETEND_TO_UPDATE_IP_;
3139   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tyissct));
3140   JITTER_PRETEND_TO_UPDATE_IP_;
3141   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(typof));
3142   JITTER_PRETEND_TO_UPDATE_IP_;
3143   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tysctn));
3144   JITTER_PRETEND_TO_UPDATE_IP_;
3145   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unmap));
3146   JITTER_PRETEND_TO_UPDATE_IP_;
3147   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unreachable));
3148   JITTER_PRETEND_TO_UPDATE_IP_;
3149   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(ureloc));
3150   JITTER_PRETEND_TO_UPDATE_IP_;
3151   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(write__retR));
3152   JITTER_PRETEND_TO_UPDATE_IP_;
3153   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aba__fR_A_mno_mfast_mbranches));
3154   JITTER_PRETEND_TO_UPDATE_IP_;
3155   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abn__fR_A_mno_mfast_mbranches));
3156   JITTER_PRETEND_TO_UPDATE_IP_;
3157   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnn__fR_A_mno_mfast_mbranches));
3158   JITTER_PRETEND_TO_UPDATE_IP_;
3159   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzi__fR_A_mno_mfast_mbranches));
3160   JITTER_PRETEND_TO_UPDATE_IP_;
3161   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnziu__fR_A_mno_mfast_mbranches));
3162   JITTER_PRETEND_TO_UPDATE_IP_;
3163   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzl__fR_A_mno_mfast_mbranches));
3164   JITTER_PRETEND_TO_UPDATE_IP_;
3165   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abnzlu__fR_A_mno_mfast_mbranches));
3166   JITTER_PRETEND_TO_UPDATE_IP_;
3167   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzi__fR_A_mno_mfast_mbranches));
3168   JITTER_PRETEND_TO_UPDATE_IP_;
3169   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abziu__fR_A_mno_mfast_mbranches));
3170   JITTER_PRETEND_TO_UPDATE_IP_;
3171   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzl__fR_A_mno_mfast_mbranches));
3172   JITTER_PRETEND_TO_UPDATE_IP_;
3173   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abzlu__fR_A_mno_mfast_mbranches));
3174   JITTER_PRETEND_TO_UPDATE_IP_;
3175   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(jitter_exit_vm_label);
3176   JITTER_PRETEND_TO_UPDATE_IP_;
3177   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(jitter_possibly_restore_registers_and_return_label);
3178   goto jitter_dispatch_label;
3179 #endif // #ifdef JITTER_REPLICATE
3180 
3181 #ifdef JITTER_DISPATCH_SWITCH
3182   /* This is the dispatching switch.  At the beginning of the first VM
3183      VM instruction and at the end of each other, control jumps here. */
3184  jitter_dispatching_switch_label:
3185   switch (jitter_ip->fixnum)
3186     {
3187 #endif // #ifdef JITTER_DISPATCH_SWITCH
3188 
3189 JITTER_INSTRUCTION_PROLOG_(!INVALID, _eINVALID, cold)
3190 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3191 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  0
3192 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !INVALID
3193 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eINVALID
3194 {
3195 
3196 jitter_fatal ("reached the !INVALID instruction");
3197 }
3198 JITTER_INSTRUCTION_EPILOG_(!INVALID, _eINVALID, 0)
3199 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3200 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3201 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3202 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3203 
3204 JITTER_INSTRUCTION_PROLOG_(!BEGINBASICBLOCK, _eBEGINBASICBLOCK, hot)
3205 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3206 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  1
3207 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !BEGINBASICBLOCK
3208 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eBEGINBASICBLOCK
3209 {
3210 
3211 #ifdef JITTER_DISPATCH_MINIMAL_THREADING
3212   JITTER_SET_IP (jitter_ip + 1);
3213 #endif // #ifdef JITTER_DISPATCH_MINIMAL_THREADING
3214 
3215 }
3216 JITTER_INSTRUCTION_EPILOG_(!BEGINBASICBLOCK, _eBEGINBASICBLOCK, 0)
3217 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3218 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3219 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3220 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3221 
3222 JITTER_INSTRUCTION_PROLOG_(!EXITVM, _eEXITVM, cold)
3223 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3224 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  2
3225 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !EXITVM
3226 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eEXITVM
3227 {
3228 
3229 JITTER_EXIT();
3230 }
3231 JITTER_INSTRUCTION_EPILOG_(!EXITVM, _eEXITVM, 0)
3232 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3233 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3234 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3235 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3236 
3237 JITTER_INSTRUCTION_PROLOG_(!DATALOCATIONS, _eDATALOCATIONS, cold)
3238 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3239 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  3
3240 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !DATALOCATIONS
3241 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eDATALOCATIONS
3242 {
3243 #ifndef JITTER_DISPATCH_SWITCH
3244 #ifndef JITTER_DISPATCH_NO_THREADING
3245   JITTER_DATA_LOCATION_DATUM ("instruction pointer", jitter_ip);
3246 #endif // #ifndef JITTER_DISPATCH_NO_THREADING
3247   JITTER_DATA_LOCATION_DATUM ("base", jitter_array_base);
3248 #ifdef JITTER_DISPATCH_NO_THREADING
3249 #ifdef JITTER_SCRATCH_REGISTER
3250   JITTER_DATA_LOCATION_DATUM ("scratch", jitter_residual_argument_scratch_register_variable);
3251 #endif // #ifdef JITTER_SCRATCH_REGISTER
3252 
3253 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
3254 #ifdef JITTER_DISPATCH_NO_THREADING
3255 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
3256   JITTER_DATA_LOCATION_DATUM ("residual 0", jitter_residual_argument_0_register_variable);
3257 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
3258 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
3259   JITTER_DATA_LOCATION_DATUM ("residual 1", jitter_residual_argument_1_register_variable);
3260 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
3261 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
3262   JITTER_DATA_LOCATION_DATUM ("residual 2", jitter_residual_argument_2_register_variable);
3263 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
3264 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
3265 #if    defined(JITTER_DISPATCH_SWITCH)                    \
3266     || defined(JITTER_DISPATCH_DIRECT_THREADING)          \
3267     || defined(JITTER_DISPATCH_MINIMAL_THREADING)         \
3268     || (   defined(JITTER_DISPATCH_NO_THREADING)          \
3269         && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE))
3270 
3271   JITTER_DATA_LOCATION_DATUM ("link register", jitter_state_runtime._jitter_link);
3272 #endif // link register
3273   JITTER_DATA_LOCATION_DATUM ("stack top",
3274      JITTER_STACK_TOS_TOP_NAME (whatever, jitter_state_runtime., stack));
3275   JITTER_DATA_LOCATION_DATUM ("stack undertop ptr",
3276      JITTER_STACK_TOS_UNDER_TOP_POINTER_NAME (whatever, jitter_state_runtime., stack));
3277   JITTER_DATA_LOCATION_DATUM ("returnstack top ptr",
3278      JITTER_STACK_NTOS_TOP_POINTER_NAME (whatever, jitter_state_runtime., returnstack));
3279   JITTER_DATA_LOCATION_DATUM ("exceptionstack top ptr",
3280      JITTER_STACK_NTOS_TOP_POINTER_NAME (whatever, jitter_state_runtime., exceptionstack));
3281 #endif // #ifndef JITTER_DISPATCH_SWITCH
3282 }
3283 JITTER_INSTRUCTION_EPILOG_(!DATALOCATIONS, _eDATALOCATIONS, 0)
3284 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3285 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3286 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3287 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3288 
3289 JITTER_INSTRUCTION_PROLOG_(!NOP, _eNOP, cold)
3290 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3291 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  4
3292 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !NOP
3293 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eNOP
3294 {
3295 
3296   /* Do nothing. */;
3297 }
3298 JITTER_INSTRUCTION_EPILOG_(!NOP, _eNOP, 0)
3299 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3300 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3301 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3302 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3303 
3304 JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE0, _eUNREACHABLE0, cold)
3305 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3306 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  5
3307 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE0
3308 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE0
3309 {
3310 
3311 jitter_fatal ("reached the !UNREACHABLE0 instruction");
3312 }
3313 JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE0, _eUNREACHABLE0, 0)
3314 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3315 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3316 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3317 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3318 
3319 JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE1, _eUNREACHABLE1, cold)
3320 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3321 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  6
3322 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE1
3323 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE1
3324 {
3325 
3326 jitter_fatal ("reached the !UNREACHABLE1 instruction");
3327 }
3328 JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE1, _eUNREACHABLE1, 0)
3329 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3330 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3331 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3332 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3333 
3334 JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE2, _eUNREACHABLE2, cold)
3335 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3336 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  7
3337 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE2
3338 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE2
3339 {
3340 
3341 jitter_fatal ("reached the !UNREACHABLE2 instruction");
3342 }
3343 JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE2, _eUNREACHABLE2, 0)
3344 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3345 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3346 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3347 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3348 
3349   /* Ordinary specialized instructions. */
3350   JITTER_INSTRUCTION_PROLOG_(addi, addi, hot)
3351   {
3352     /* This specialized instruction is not a replacement. */
3353 #   undef JITTER_BRANCH_FAST
3354 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3355 #   undef JITTER_BRANCH_FAST_IF_ZERO
3356 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3357 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3358 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3359 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3360 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3361 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3362 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3363 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3364 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3365 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3366 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3367 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3368 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3369 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3370 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3371 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3372 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3373 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3374 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3375 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3376 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3377 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3378 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3379 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3380 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3381 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3382 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3383 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3384 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3385 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3386 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3387 #   undef JITTER_BRANCH_FAST_IF_AND
3388 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3389 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3390 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3391 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3392 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3393 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3394 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3395 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3396 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3397 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3398 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3399 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3400 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3401 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3402 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3403 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3404 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3405 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3406 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3407 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3408 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3409 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3410 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3411 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3412 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3413 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3414 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3415 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3416 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3417 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       8
3418 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         addi
3419 
3420 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME addi
3421 
3422   /* The residual arity for this instruction does not depend on fast labels. */
3423   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3424 
3425 
3426 #if defined (JITTER_PROFILE_SAMPLE)
3427   JITTER_PROFILE_SAMPLE_UPDATE
3428      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3429       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3430   /* Force the compiler not move sample-profiling instrumentation
3431      beyond this point; this way the actual user code is timed.
3432      This is still not perfect, as residuals are materialised before
3433      we arrive here, but should be adequate at least for slow VM
3434      instructions. */
3435   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3436 #endif
3437 #if defined (JITTER_PROFILE_COUNT)
3438   /* Notice that, differently from the code above, this
3439      instrumentation code *can* be reordered freely: as long as a
3440      VM instruction is counted, the count increment can be placed
3441      anyehere.  Let GCC move this code and possibly achieve better
3442      throughput by exploiting instruction-level parallelism and
3443      therefore approximate more closely a non-profiled build. */
3444   JITTER_PROFILE_COUNT_UPDATE
3445      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3446       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3447 #endif
3448 
3449 /* User-specified code, instruction-beginning-c part: beginning. */
3450 
3451 /* User-specified code, instruction-beginning-c part: end */
3452 
3453 
3454     /* User code for addi . */
3455 #line 2297 "../../libpoke/pvm.jitter"
3456 
3457     PVM_ADD_SIGNED (INT,int);
3458 
3459     /* End of the user code for addi . */
3460 
3461 /* User-specified code, instruction-end-c part: beginning. */
3462 
3463 /* User-specified code, instruction-end-c part: end */
3464 
3465     /* Undefine the addi argument macros so they can't be used
3466        by mistake in the instruction body coming next. */
3467 
3468 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3469 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3470 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3471 
3472   }
3473  JITTER_INSTRUCTION_EPILOG_(addi, addi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3474 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3475 
3476   JITTER_INSTRUCTION_PROLOG_(addiu, addiu, hot)
3477   {
3478     /* This specialized instruction is not a replacement. */
3479 #   undef JITTER_BRANCH_FAST
3480 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3481 #   undef JITTER_BRANCH_FAST_IF_ZERO
3482 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3483 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3484 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3485 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3486 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3487 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3488 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3489 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3490 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3491 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3492 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3493 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3494 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3495 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3496 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3497 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3498 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3499 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3500 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3501 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3502 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3503 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3504 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3505 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3506 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3507 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3508 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3509 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3510 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3511 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3512 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3513 #   undef JITTER_BRANCH_FAST_IF_AND
3514 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3515 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3516 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3517 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3518 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3519 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3520 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3521 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3522 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3523 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3524 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3525 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3526 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3527 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3528 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3529 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3530 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3531 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3532 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3533 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3534 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3535 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3536 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3537 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3538 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3539 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3540 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3541 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3542 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3543 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       9
3544 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         addiu
3545 
3546 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME addiu
3547 
3548   /* The residual arity for this instruction does not depend on fast labels. */
3549   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3550 
3551 
3552 #if defined (JITTER_PROFILE_SAMPLE)
3553   JITTER_PROFILE_SAMPLE_UPDATE
3554      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3555       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3556   /* Force the compiler not move sample-profiling instrumentation
3557      beyond this point; this way the actual user code is timed.
3558      This is still not perfect, as residuals are materialised before
3559      we arrive here, but should be adequate at least for slow VM
3560      instructions. */
3561   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3562 #endif
3563 #if defined (JITTER_PROFILE_COUNT)
3564   /* Notice that, differently from the code above, this
3565      instrumentation code *can* be reordered freely: as long as a
3566      VM instruction is counted, the count increment can be placed
3567      anyehere.  Let GCC move this code and possibly achieve better
3568      throughput by exploiting instruction-level parallelism and
3569      therefore approximate more closely a non-profiled build. */
3570   JITTER_PROFILE_COUNT_UPDATE
3571      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3572       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3573 #endif
3574 
3575 /* User-specified code, instruction-beginning-c part: beginning. */
3576 
3577 /* User-specified code, instruction-beginning-c part: end */
3578 
3579 
3580     /* User code for addiu . */
3581 #line 2310 "../../libpoke/pvm.jitter"
3582 
3583     PVM_BINOP (UINT, UINT, UINT, +);
3584 
3585     /* End of the user code for addiu . */
3586 
3587 /* User-specified code, instruction-end-c part: beginning. */
3588 
3589 /* User-specified code, instruction-end-c part: end */
3590 
3591     /* Undefine the addiu argument macros so they can't be used
3592        by mistake in the instruction body coming next. */
3593 
3594 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3595 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3596 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3597 
3598   }
3599  JITTER_INSTRUCTION_EPILOG_(addiu, addiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3600 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3601 
3602   JITTER_INSTRUCTION_PROLOG_(addl, addl, hot)
3603   {
3604     /* This specialized instruction is not a replacement. */
3605 #   undef JITTER_BRANCH_FAST
3606 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3607 #   undef JITTER_BRANCH_FAST_IF_ZERO
3608 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3609 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3610 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3611 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3612 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3613 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3614 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3615 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3616 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3617 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3618 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3619 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3620 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3621 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3622 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3623 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3624 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3625 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3626 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3627 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3628 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3629 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3630 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3631 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3632 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3633 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3634 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3635 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3636 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3637 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3638 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3639 #   undef JITTER_BRANCH_FAST_IF_AND
3640 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3641 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3642 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3643 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3644 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3645 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3646 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3647 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3648 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3649 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3650 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3651 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3652 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3653 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3654 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3655 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3656 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3657 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3658 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3659 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3660 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3661 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3662 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3663 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3664 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3665 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3666 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3667 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3668 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3669 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       10
3670 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         addl
3671 
3672 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME addl
3673 
3674   /* The residual arity for this instruction does not depend on fast labels. */
3675   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3676 
3677 
3678 #if defined (JITTER_PROFILE_SAMPLE)
3679   JITTER_PROFILE_SAMPLE_UPDATE
3680      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3681       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3682   /* Force the compiler not move sample-profiling instrumentation
3683      beyond this point; this way the actual user code is timed.
3684      This is still not perfect, as residuals are materialised before
3685      we arrive here, but should be adequate at least for slow VM
3686      instructions. */
3687   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3688 #endif
3689 #if defined (JITTER_PROFILE_COUNT)
3690   /* Notice that, differently from the code above, this
3691      instrumentation code *can* be reordered freely: as long as a
3692      VM instruction is counted, the count increment can be placed
3693      anyehere.  Let GCC move this code and possibly achieve better
3694      throughput by exploiting instruction-level parallelism and
3695      therefore approximate more closely a non-profiled build. */
3696   JITTER_PROFILE_COUNT_UPDATE
3697      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3698       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3699 #endif
3700 
3701 /* User-specified code, instruction-beginning-c part: beginning. */
3702 
3703 /* User-specified code, instruction-beginning-c part: end */
3704 
3705 
3706     /* User code for addl . */
3707 #line 2324 "../../libpoke/pvm.jitter"
3708 
3709     PVM_ADD_SIGNED (LONG, int64_t);
3710 
3711     /* End of the user code for addl . */
3712 
3713 /* User-specified code, instruction-end-c part: beginning. */
3714 
3715 /* User-specified code, instruction-end-c part: end */
3716 
3717     /* Undefine the addl argument macros so they can't be used
3718        by mistake in the instruction body coming next. */
3719 
3720 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3721 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3722 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3723 
3724   }
3725  JITTER_INSTRUCTION_EPILOG_(addl, addl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3726 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3727 
3728   JITTER_INSTRUCTION_PROLOG_(addlu, addlu, hot)
3729   {
3730     /* This specialized instruction is not a replacement. */
3731 #   undef JITTER_BRANCH_FAST
3732 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3733 #   undef JITTER_BRANCH_FAST_IF_ZERO
3734 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3735 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3736 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3737 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3738 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3739 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3740 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3741 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3742 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3743 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3744 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3745 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3746 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3747 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3748 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3749 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3750 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3751 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3752 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3753 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3754 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3755 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3756 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3757 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3758 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3759 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3760 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3761 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3762 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3763 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3764 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3765 #   undef JITTER_BRANCH_FAST_IF_AND
3766 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3767 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3768 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3769 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3770 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3771 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3772 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3773 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3774 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3775 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3776 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3777 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3778 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3779 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3780 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3781 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3782 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3783 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3784 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3785 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3786 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3787 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3788 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3789 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3790 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3791 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3792 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3793 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3794 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3795 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       11
3796 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         addlu
3797 
3798 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME addlu
3799 
3800   /* The residual arity for this instruction does not depend on fast labels. */
3801   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3802 
3803 
3804 #if defined (JITTER_PROFILE_SAMPLE)
3805   JITTER_PROFILE_SAMPLE_UPDATE
3806      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3807       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3808   /* Force the compiler not move sample-profiling instrumentation
3809      beyond this point; this way the actual user code is timed.
3810      This is still not perfect, as residuals are materialised before
3811      we arrive here, but should be adequate at least for slow VM
3812      instructions. */
3813   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3814 #endif
3815 #if defined (JITTER_PROFILE_COUNT)
3816   /* Notice that, differently from the code above, this
3817      instrumentation code *can* be reordered freely: as long as a
3818      VM instruction is counted, the count increment can be placed
3819      anyehere.  Let GCC move this code and possibly achieve better
3820      throughput by exploiting instruction-level parallelism and
3821      therefore approximate more closely a non-profiled build. */
3822   JITTER_PROFILE_COUNT_UPDATE
3823      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3824       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3825 #endif
3826 
3827 /* User-specified code, instruction-beginning-c part: beginning. */
3828 
3829 /* User-specified code, instruction-beginning-c part: end */
3830 
3831 
3832     /* User code for addlu . */
3833 #line 2337 "../../libpoke/pvm.jitter"
3834 
3835     PVM_BINOP (ULONG, ULONG, ULONG, +);
3836 
3837     /* End of the user code for addlu . */
3838 
3839 /* User-specified code, instruction-end-c part: beginning. */
3840 
3841 /* User-specified code, instruction-end-c part: end */
3842 
3843     /* Undefine the addlu argument macros so they can't be used
3844        by mistake in the instruction body coming next. */
3845 
3846 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3847 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3848 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3849 
3850   }
3851  JITTER_INSTRUCTION_EPILOG_(addlu, addlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3852 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3853 
3854   JITTER_INSTRUCTION_PROLOG_(ains, ains, hot)
3855   {
3856     /* This specialized instruction is not a replacement. */
3857 #   undef JITTER_BRANCH_FAST
3858 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3859 #   undef JITTER_BRANCH_FAST_IF_ZERO
3860 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3861 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3862 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3863 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3864 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3865 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3866 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3867 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3868 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3869 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3870 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3871 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3872 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3873 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3874 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3875 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3876 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3877 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3878 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3879 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3880 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3881 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3882 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3883 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3884 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3885 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3886 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3887 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3888 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3889 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3890 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3891 #   undef JITTER_BRANCH_FAST_IF_AND
3892 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3893 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3894 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3895 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3896 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3897 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3898 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3899 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3900 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3901 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3902 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3903 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3904 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3905 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3906 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3907 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3908 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3909 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3910 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3911 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3912 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3913 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3914 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3915 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3916 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3917 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3918 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3919 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3920 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3921 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       12
3922 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ains
3923 
3924 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ains
3925 
3926   /* The residual arity for this instruction does not depend on fast labels. */
3927   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3928 
3929 
3930 #if defined (JITTER_PROFILE_SAMPLE)
3931   JITTER_PROFILE_SAMPLE_UPDATE
3932      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3933       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3934   /* Force the compiler not move sample-profiling instrumentation
3935      beyond this point; this way the actual user code is timed.
3936      This is still not perfect, as residuals are materialised before
3937      we arrive here, but should be adequate at least for slow VM
3938      instructions. */
3939   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3940 #endif
3941 #if defined (JITTER_PROFILE_COUNT)
3942   /* Notice that, differently from the code above, this
3943      instrumentation code *can* be reordered freely: as long as a
3944      VM instruction is counted, the count increment can be placed
3945      anyehere.  Let GCC move this code and possibly achieve better
3946      throughput by exploiting instruction-level parallelism and
3947      therefore approximate more closely a non-profiled build. */
3948   JITTER_PROFILE_COUNT_UPDATE
3949      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3950       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3951 #endif
3952 
3953 /* User-specified code, instruction-beginning-c part: beginning. */
3954 
3955 /* User-specified code, instruction-beginning-c part: end */
3956 
3957 
3958     /* User code for ains . */
3959 #line 4137 "../../libpoke/pvm.jitter"
3960 
3961     pvm_val val = JITTER_TOP_STACK ();
3962     pvm_val idx = JITTER_UNDER_TOP_STACK ();
3963     pvm_val arr;
3964 
3965     JITTER_DROP_STACK ();
3966     JITTER_DROP_STACK ();
3967     arr = JITTER_TOP_STACK ();
3968 
3969     if (PVM_VAL_ULONG (idx) < PVM_VAL_ULONG (PVM_VAL_ARR_NELEM (arr)))
3970       /* Note that pvm_array_set can't return 0 here due
3971          to the index check.  */
3972       pvm_array_set (arr, idx, val);
3973     else
3974     {
3975       if (!pvm_array_insert (arr, idx, val))
3976         PVM_RAISE_DFL (PVM_E_INVAL);
3977     }
3978 
3979     /* End of the user code for ains . */
3980 
3981 /* User-specified code, instruction-end-c part: beginning. */
3982 
3983 /* User-specified code, instruction-end-c part: end */
3984 
3985     /* Undefine the ains argument macros so they can't be used
3986        by mistake in the instruction body coming next. */
3987 
3988 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3989 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3990 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3991 
3992   }
3993  JITTER_INSTRUCTION_EPILOG_(ains, ains, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3994 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3995 
3996   JITTER_INSTRUCTION_PROLOG_(and, and, hot)
3997   {
3998     /* This specialized instruction is not a replacement. */
3999 #   undef JITTER_BRANCH_FAST
4000 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4001 #   undef JITTER_BRANCH_FAST_IF_ZERO
4002 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4003 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4004 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4005 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4006 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4007 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4008 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4009 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4010 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4011 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4012 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4013 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4014 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4015 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4016 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4017 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4018 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4019 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4020 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4021 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4022 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4023 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4024 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4025 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4026 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4027 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4028 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4029 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4030 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4031 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4032 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4033 #   undef JITTER_BRANCH_FAST_IF_AND
4034 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4035 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4036 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4037 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4038 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4039 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4040 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4041 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4042 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4043 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4044 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4045 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4046 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4047 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4048 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4049 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4050 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4051 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4052 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4053 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4054 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4055 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4056 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4057 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4058 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4059 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4060 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4061 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4062 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4063 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       13
4064 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         and
4065 
4066 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME and
4067 
4068   /* The residual arity for this instruction does not depend on fast labels. */
4069   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
4070 
4071 
4072 #if defined (JITTER_PROFILE_SAMPLE)
4073   JITTER_PROFILE_SAMPLE_UPDATE
4074      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4075       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4076   /* Force the compiler not move sample-profiling instrumentation
4077      beyond this point; this way the actual user code is timed.
4078      This is still not perfect, as residuals are materialised before
4079      we arrive here, but should be adequate at least for slow VM
4080      instructions. */
4081   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4082 #endif
4083 #if defined (JITTER_PROFILE_COUNT)
4084   /* Notice that, differently from the code above, this
4085      instrumentation code *can* be reordered freely: as long as a
4086      VM instruction is counted, the count increment can be placed
4087      anyehere.  Let GCC move this code and possibly achieve better
4088      throughput by exploiting instruction-level parallelism and
4089      therefore approximate more closely a non-profiled build. */
4090   JITTER_PROFILE_COUNT_UPDATE
4091      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4092       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4093 #endif
4094 
4095 /* User-specified code, instruction-beginning-c part: beginning. */
4096 
4097 /* User-specified code, instruction-beginning-c part: end */
4098 
4099 
4100     /* User code for and . */
4101 #line 3142 "../../libpoke/pvm.jitter"
4102 
4103     PVM_BOOL_BINOP (INT, &&);
4104 
4105     /* End of the user code for and . */
4106 
4107 /* User-specified code, instruction-end-c part: beginning. */
4108 
4109 /* User-specified code, instruction-end-c part: end */
4110 
4111     /* Undefine the and argument macros so they can't be used
4112        by mistake in the instruction body coming next. */
4113 
4114 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4115 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4116 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4117 
4118   }
4119  JITTER_INSTRUCTION_EPILOG_(and, and, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4120 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4121 
4122   JITTER_INSTRUCTION_PROLOG_(aref, aref, hot)
4123   {
4124     /* This specialized instruction is not a replacement. */
4125 #   undef JITTER_BRANCH_FAST
4126 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4127 #   undef JITTER_BRANCH_FAST_IF_ZERO
4128 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4129 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4130 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4131 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4132 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4133 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4134 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4135 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4136 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4137 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4138 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4139 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4140 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4141 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4142 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4143 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4144 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4145 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4146 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4147 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4148 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4149 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4150 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4151 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4152 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4153 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4154 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4155 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4156 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4157 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4158 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4159 #   undef JITTER_BRANCH_FAST_IF_AND
4160 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4161 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4162 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4163 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4164 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4165 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4166 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4167 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4168 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4169 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4170 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4171 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4172 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4173 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4174 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4175 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4176 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4177 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4178 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4179 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4180 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4181 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4182 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4183 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4184 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4185 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4186 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4187 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4188 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4189 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       14
4190 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         aref
4191 
4192 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME aref
4193 
4194   /* The residual arity for this instruction does not depend on fast labels. */
4195   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
4196 
4197 
4198 #if defined (JITTER_PROFILE_SAMPLE)
4199   JITTER_PROFILE_SAMPLE_UPDATE
4200      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4201       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4202   /* Force the compiler not move sample-profiling instrumentation
4203      beyond this point; this way the actual user code is timed.
4204      This is still not perfect, as residuals are materialised before
4205      we arrive here, but should be adequate at least for slow VM
4206      instructions. */
4207   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4208 #endif
4209 #if defined (JITTER_PROFILE_COUNT)
4210   /* Notice that, differently from the code above, this
4211      instrumentation code *can* be reordered freely: as long as a
4212      VM instruction is counted, the count increment can be placed
4213      anyehere.  Let GCC move this code and possibly achieve better
4214      throughput by exploiting instruction-level parallelism and
4215      therefore approximate more closely a non-profiled build. */
4216   JITTER_PROFILE_COUNT_UPDATE
4217      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4218       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4219 #endif
4220 
4221 /* User-specified code, instruction-beginning-c part: beginning. */
4222 
4223 /* User-specified code, instruction-beginning-c part: end */
4224 
4225 
4226     /* User code for aref . */
4227 #line 4260 "../../libpoke/pvm.jitter"
4228 
4229     pvm_val array = JITTER_UNDER_TOP_STACK ();
4230     pvm_val index = JITTER_TOP_STACK ();
4231 
4232     if ((PVM_VAL_ULONG (index) >=
4233             PVM_VAL_INTEGRAL (PVM_VAL_ARR_NELEM (array))))
4234       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
4235 
4236     JITTER_PUSH_STACK (PVM_VAL_ARR_ELEM_VALUE (array,
4237                                                PVM_VAL_ULONG (index)));
4238 
4239     /* End of the user code for aref . */
4240 
4241 /* User-specified code, instruction-end-c part: beginning. */
4242 
4243 /* User-specified code, instruction-end-c part: end */
4244 
4245     /* Undefine the aref argument macros so they can't be used
4246        by mistake in the instruction body coming next. */
4247 
4248 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4249 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4250 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4251 
4252   }
4253  JITTER_INSTRUCTION_EPILOG_(aref, aref, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4254 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4255 
4256   JITTER_INSTRUCTION_PROLOG_(arefo, arefo, hot)
4257   {
4258     /* This specialized instruction is not a replacement. */
4259 #   undef JITTER_BRANCH_FAST
4260 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4261 #   undef JITTER_BRANCH_FAST_IF_ZERO
4262 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4263 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4264 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4265 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4266 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4267 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4268 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4269 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4270 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4271 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4272 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4273 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4274 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4275 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4276 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4277 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4278 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4279 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4280 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4281 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4282 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4283 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4284 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4285 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4286 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4287 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4288 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4289 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4290 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4291 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4292 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4293 #   undef JITTER_BRANCH_FAST_IF_AND
4294 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4295 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4296 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4297 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4298 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4299 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4300 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4301 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4302 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4303 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4304 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4305 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4306 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4307 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4308 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4309 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4310 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4311 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4312 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4313 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4314 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4315 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4316 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4317 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4318 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4319 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4320 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4321 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4322 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4323 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       15
4324 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         arefo
4325 
4326 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME arefo
4327 
4328   /* The residual arity for this instruction does not depend on fast labels. */
4329   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
4330 
4331 
4332 #if defined (JITTER_PROFILE_SAMPLE)
4333   JITTER_PROFILE_SAMPLE_UPDATE
4334      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4335       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4336   /* Force the compiler not move sample-profiling instrumentation
4337      beyond this point; this way the actual user code is timed.
4338      This is still not perfect, as residuals are materialised before
4339      we arrive here, but should be adequate at least for slow VM
4340      instructions. */
4341   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4342 #endif
4343 #if defined (JITTER_PROFILE_COUNT)
4344   /* Notice that, differently from the code above, this
4345      instrumentation code *can* be reordered freely: as long as a
4346      VM instruction is counted, the count increment can be placed
4347      anyehere.  Let GCC move this code and possibly achieve better
4348      throughput by exploiting instruction-level parallelism and
4349      therefore approximate more closely a non-profiled build. */
4350   JITTER_PROFILE_COUNT_UPDATE
4351      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4352       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4353 #endif
4354 
4355 /* User-specified code, instruction-beginning-c part: beginning. */
4356 
4357 /* User-specified code, instruction-beginning-c part: end */
4358 
4359 
4360     /* User code for arefo . */
4361 #line 4285 "../../libpoke/pvm.jitter"
4362 
4363     pvm_val array = JITTER_UNDER_TOP_STACK ();
4364     pvm_val index = JITTER_TOP_STACK ();
4365 
4366     if (PVM_VAL_ULONG (index) < 0
4367         || (PVM_VAL_ULONG (index) >=
4368             PVM_VAL_INTEGRAL (PVM_VAL_ARR_NELEM (array))))
4369       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
4370 
4371     JITTER_PUSH_STACK (PVM_VAL_ARR_ELEM_OFFSET (array,
4372                                                 PVM_VAL_ULONG (index)));
4373 
4374     /* End of the user code for arefo . */
4375 
4376 /* User-specified code, instruction-end-c part: beginning. */
4377 
4378 /* User-specified code, instruction-end-c part: end */
4379 
4380     /* Undefine the arefo argument macros so they can't be used
4381        by mistake in the instruction body coming next. */
4382 
4383 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4384 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4385 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4386 
4387   }
4388  JITTER_INSTRUCTION_EPILOG_(arefo, arefo, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4389 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4390 
4391   JITTER_INSTRUCTION_PROLOG_(arem, arem, hot)
4392   {
4393     /* This specialized instruction is not a replacement. */
4394 #   undef JITTER_BRANCH_FAST
4395 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4396 #   undef JITTER_BRANCH_FAST_IF_ZERO
4397 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4398 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4399 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4400 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4401 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4402 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4403 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4404 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4405 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4406 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4407 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4408 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4409 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4410 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4411 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4412 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4413 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4414 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4415 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4416 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4417 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4418 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4419 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4420 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4421 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4422 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4423 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4424 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4425 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4426 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4427 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4428 #   undef JITTER_BRANCH_FAST_IF_AND
4429 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4430 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4431 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4432 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4433 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4434 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4435 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4436 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4437 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4438 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4439 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4440 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4441 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4442 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4443 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4444 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4445 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4446 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4447 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4448 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4449 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4450 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4451 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4452 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4453 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4454 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4455 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4456 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4457 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4458 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       16
4459 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         arem
4460 
4461 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME arem
4462 
4463   /* The residual arity for this instruction does not depend on fast labels. */
4464   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
4465 
4466 
4467 #if defined (JITTER_PROFILE_SAMPLE)
4468   JITTER_PROFILE_SAMPLE_UPDATE
4469      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4470       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4471   /* Force the compiler not move sample-profiling instrumentation
4472      beyond this point; this way the actual user code is timed.
4473      This is still not perfect, as residuals are materialised before
4474      we arrive here, but should be adequate at least for slow VM
4475      instructions. */
4476   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4477 #endif
4478 #if defined (JITTER_PROFILE_COUNT)
4479   /* Notice that, differently from the code above, this
4480      instrumentation code *can* be reordered freely: as long as a
4481      VM instruction is counted, the count increment can be placed
4482      anyehere.  Let GCC move this code and possibly achieve better
4483      throughput by exploiting instruction-level parallelism and
4484      therefore approximate more closely a non-profiled build. */
4485   JITTER_PROFILE_COUNT_UPDATE
4486      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4487       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4488 #endif
4489 
4490 /* User-specified code, instruction-beginning-c part: beginning. */
4491 
4492 /* User-specified code, instruction-beginning-c part: end */
4493 
4494 
4495     /* User code for arem . */
4496 #line 4170 "../../libpoke/pvm.jitter"
4497 
4498     pvm_val arr = JITTER_UNDER_TOP_STACK ();
4499     pvm_val idx = JITTER_TOP_STACK ();
4500 
4501     if (PVM_VAL_ULONG (idx) >= PVM_VAL_ULONG (PVM_VAL_ARR_NELEM (arr)))
4502       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
4503 
4504     /* This call can't fail (return 0) due to the index check above.  */
4505     (void) pvm_array_rem (arr, idx);
4506     JITTER_DROP_STACK ();
4507 
4508     /* End of the user code for arem . */
4509 
4510 /* User-specified code, instruction-end-c part: beginning. */
4511 
4512 /* User-specified code, instruction-end-c part: end */
4513 
4514     /* Undefine the arem argument macros so they can't be used
4515        by mistake in the instruction body coming next. */
4516 
4517 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4518 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4519 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4520 
4521   }
4522  JITTER_INSTRUCTION_EPILOG_(arem, arem, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4523 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4524 
4525   JITTER_INSTRUCTION_PROLOG_(aset, aset, hot)
4526   {
4527     /* This specialized instruction is not a replacement. */
4528 #   undef JITTER_BRANCH_FAST
4529 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4530 #   undef JITTER_BRANCH_FAST_IF_ZERO
4531 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4532 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4533 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4534 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4535 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4536 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4537 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4538 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4539 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4540 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4541 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4542 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4543 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4544 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4545 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4546 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4547 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4548 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4549 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4550 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4551 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4552 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4553 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4554 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4555 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4556 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4557 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4558 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4559 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4560 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4561 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4562 #   undef JITTER_BRANCH_FAST_IF_AND
4563 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4564 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4565 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4566 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4567 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4568 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4569 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4570 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4571 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4572 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4573 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4574 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4575 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4576 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4577 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4578 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4579 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4580 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4581 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4582 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4583 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4584 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4585 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4586 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4587 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4588 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4589 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4590 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4591 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4592 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       17
4593 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         aset
4594 
4595 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME aset
4596 
4597   /* The residual arity for this instruction does not depend on fast labels. */
4598   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
4599 
4600 
4601 #if defined (JITTER_PROFILE_SAMPLE)
4602   JITTER_PROFILE_SAMPLE_UPDATE
4603      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4604       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4605   /* Force the compiler not move sample-profiling instrumentation
4606      beyond this point; this way the actual user code is timed.
4607      This is still not perfect, as residuals are materialised before
4608      we arrive here, but should be adequate at least for slow VM
4609      instructions. */
4610   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4611 #endif
4612 #if defined (JITTER_PROFILE_COUNT)
4613   /* Notice that, differently from the code above, this
4614      instrumentation code *can* be reordered freely: as long as a
4615      VM instruction is counted, the count increment can be placed
4616      anyehere.  Let GCC move this code and possibly achieve better
4617      throughput by exploiting instruction-level parallelism and
4618      therefore approximate more closely a non-profiled build. */
4619   JITTER_PROFILE_COUNT_UPDATE
4620      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4621       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4622 #endif
4623 
4624 /* User-specified code, instruction-beginning-c part: beginning. */
4625 
4626 /* User-specified code, instruction-beginning-c part: end */
4627 
4628 
4629     /* User code for aset . */
4630 #line 4197 "../../libpoke/pvm.jitter"
4631 
4632     pvm_val idx;
4633     pvm_val val;
4634     pvm_val arr;
4635     pvm_val array_type, bound;
4636     size_t index;
4637 
4638     val= JITTER_TOP_STACK ();
4639     idx = JITTER_UNDER_TOP_STACK ();
4640     index = PVM_VAL_ULONG (idx);
4641     JITTER_DROP_STACK ();
4642     JITTER_DROP_STACK ();
4643 
4644     arr = JITTER_TOP_STACK ();
4645 
4646     if (index >= PVM_VAL_INTEGRAL (PVM_VAL_ARR_NELEM (arr)))
4647       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
4648 
4649     /* If the array is bounded by size, check whether the new value
4650        results in a different size.  */
4651     array_type = PVM_VAL_ARR_TYPE (arr);
4652     bound = PVM_VAL_TYP_A_BOUND (array_type);
4653 
4654     if (PVM_IS_OFF (bound))
4655       {
4656         pvm_val oval = PVM_VAL_ARR_ELEM_VALUE (arr, index);
4657         uint64_t old_size_bits;
4658         uint64_t new_size_bits;
4659 
4660         PVM_VAL_ARR_ELEM_VALUE (arr, index) = val;
4661 
4662         old_size_bits = (PVM_VAL_INTEGRAL (PVM_VAL_OFF_MAGNITUDE (bound))
4663                          * PVM_VAL_INTEGRAL (PVM_VAL_OFF_UNIT (bound)));
4664         new_size_bits = pvm_sizeof (arr);
4665 
4666         if (new_size_bits != old_size_bits)
4667          {
4668            PVM_VAL_ARR_ELEM_VALUE (arr, index) = oval;
4669            PVM_RAISE_DFL (PVM_E_CONV);
4670          }
4671       }
4672    else
4673       {
4674         /* Note that pvm_aray_set cannot fail here, due to the check
4675            on index above.  This is done like this in order to avoid
4676            checking the bound by size if the index is out of bounds.  */
4677          pvm_array_set (arr, idx, val);
4678       }
4679 
4680     /* End of the user code for aset . */
4681 
4682 /* User-specified code, instruction-end-c part: beginning. */
4683 
4684 /* User-specified code, instruction-end-c part: end */
4685 
4686     /* Undefine the aset argument macros so they can't be used
4687        by mistake in the instruction body coming next. */
4688 
4689 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4690 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4691 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4692 
4693   }
4694  JITTER_INSTRUCTION_EPILOG_(aset, aset, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4695 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4696 
4697   JITTER_INSTRUCTION_PROLOG_(asettb, asettb, hot)
4698   {
4699     /* This specialized instruction is not a replacement. */
4700 #   undef JITTER_BRANCH_FAST
4701 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4702 #   undef JITTER_BRANCH_FAST_IF_ZERO
4703 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4704 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4705 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4706 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4707 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4708 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4709 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4710 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4711 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4712 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4713 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4714 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4715 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4716 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4717 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4718 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4719 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4720 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4721 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4722 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4723 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4724 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4725 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4726 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4727 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4728 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4729 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4730 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4731 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4732 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4733 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4734 #   undef JITTER_BRANCH_FAST_IF_AND
4735 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4736 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4737 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4738 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4739 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4740 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4741 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4742 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4743 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4744 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4745 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4746 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4747 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4748 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4749 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4750 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4751 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4752 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4753 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4754 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4755 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4756 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4757 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4758 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4759 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4760 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4761 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4762 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4763 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4764 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       18
4765 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         asettb
4766 
4767 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME asettb
4768 
4769   /* The residual arity for this instruction does not depend on fast labels. */
4770   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
4771 
4772 
4773 #if defined (JITTER_PROFILE_SAMPLE)
4774   JITTER_PROFILE_SAMPLE_UPDATE
4775      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4776       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4777   /* Force the compiler not move sample-profiling instrumentation
4778      beyond this point; this way the actual user code is timed.
4779      This is still not perfect, as residuals are materialised before
4780      we arrive here, but should be adequate at least for slow VM
4781      instructions. */
4782   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4783 #endif
4784 #if defined (JITTER_PROFILE_COUNT)
4785   /* Notice that, differently from the code above, this
4786      instrumentation code *can* be reordered freely: as long as a
4787      VM instruction is counted, the count increment can be placed
4788      anyehere.  Let GCC move this code and possibly achieve better
4789      throughput by exploiting instruction-level parallelism and
4790      therefore approximate more closely a non-profiled build. */
4791   JITTER_PROFILE_COUNT_UPDATE
4792      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4793       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4794 #endif
4795 
4796 /* User-specified code, instruction-beginning-c part: beginning. */
4797 
4798 /* User-specified code, instruction-beginning-c part: end */
4799 
4800 
4801     /* User code for asettb . */
4802 #line 4308 "../../libpoke/pvm.jitter"
4803 
4804     pvm_val type = PVM_VAL_ARR_TYPE (JITTER_UNDER_TOP_STACK ());
4805 
4806     PVM_VAL_TYP_A_BOUND (type) = JITTER_TOP_STACK ();
4807     JITTER_DROP_STACK ();
4808 
4809     /* End of the user code for asettb . */
4810 
4811 /* User-specified code, instruction-end-c part: beginning. */
4812 
4813 /* User-specified code, instruction-end-c part: end */
4814 
4815     /* Undefine the asettb argument macros so they can't be used
4816        by mistake in the instruction body coming next. */
4817 
4818 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4819 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4820 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4821 
4822   }
4823  JITTER_INSTRUCTION_EPILOG_(asettb, asettb, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4824 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4825 
4826   JITTER_INSTRUCTION_PROLOG_(atr, atr, hot)
4827   {
4828     /* This specialized instruction is not a replacement. */
4829 #   undef JITTER_BRANCH_FAST
4830 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4831 #   undef JITTER_BRANCH_FAST_IF_ZERO
4832 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4833 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4834 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4835 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4836 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4837 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4838 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4839 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4840 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4841 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4842 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4843 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4844 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4845 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4846 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4847 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4848 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4849 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4850 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4851 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4852 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4853 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4854 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4855 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4856 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4857 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4858 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4859 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4860 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4861 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4862 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4863 #   undef JITTER_BRANCH_FAST_IF_AND
4864 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4865 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4866 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4867 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4868 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4869 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4870 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4871 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4872 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4873 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4874 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4875 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4876 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4877 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4878 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4879 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4880 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4881 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4882 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4883 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4884 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4885 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4886 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4887 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4888 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4889 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4890 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4891 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4892 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4893 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       19
4894 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         atr
4895 
4896 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME atr
4897 
4898   /* The residual arity for this instruction does not depend on fast labels. */
4899   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
4900 
4901 
4902 #if defined (JITTER_PROFILE_SAMPLE)
4903   JITTER_PROFILE_SAMPLE_UPDATE
4904      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4905       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4906   /* Force the compiler not move sample-profiling instrumentation
4907      beyond this point; this way the actual user code is timed.
4908      This is still not perfect, as residuals are materialised before
4909      we arrive here, but should be adequate at least for slow VM
4910      instructions. */
4911   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4912 #endif
4913 #if defined (JITTER_PROFILE_COUNT)
4914   /* Notice that, differently from the code above, this
4915      instrumentation code *can* be reordered freely: as long as a
4916      VM instruction is counted, the count increment can be placed
4917      anyehere.  Let GCC move this code and possibly achieve better
4918      throughput by exploiting instruction-level parallelism and
4919      therefore approximate more closely a non-profiled build. */
4920   JITTER_PROFILE_COUNT_UPDATE
4921      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4922       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4923 #endif
4924 
4925 /* User-specified code, instruction-beginning-c part: beginning. */
4926 
4927 /* User-specified code, instruction-beginning-c part: end */
4928 
4929 
4930     /* User code for atr . */
4931 #line 2277 "../../libpoke/pvm.jitter"
4932 
4933     JITTER_PUSH_STACK (JITTER_TOP_RETURNSTACK ());
4934 
4935     /* End of the user code for atr . */
4936 
4937 /* User-specified code, instruction-end-c part: beginning. */
4938 
4939 /* User-specified code, instruction-end-c part: end */
4940 
4941     /* Undefine the atr argument macros so they can't be used
4942        by mistake in the instruction body coming next. */
4943 
4944 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4945 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4946 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4947 
4948   }
4949  JITTER_INSTRUCTION_EPILOG_(atr, atr, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4950 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4951 
4952   JITTER_INSTRUCTION_PROLOG_(ba/fR, ba__fR, hot)
4953   {
4954     /* This specialized instruction is not a replacement. */
4955 #   undef JITTER_BRANCH_FAST
4956 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4957 #   undef JITTER_BRANCH_FAST_IF_ZERO
4958 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4959 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4960 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4961 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4962 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4963 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4964 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4965 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4966 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4967 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4968 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4969 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4970 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4971 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4972 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4973 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4974 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4975 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4976 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4977 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4978 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4979 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4980 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4981 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4982 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4983 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4984 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4985 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4986 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4987 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4988 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4989 #   undef JITTER_BRANCH_FAST_IF_AND
4990 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4991 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4992 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4993 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4994 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4995 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4996 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4997 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4998 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4999 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5000 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5001 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5002 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5003 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5004 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5005 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5006 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5007 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5008 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5009 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5010 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5011 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5012 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5013 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5014 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5015 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5016 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5017 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5018 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5019 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       20
5020 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ba/fR
5021 
5022 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ba__fR
5023 
5024   /* The residual arity varies depending on whether we have fast labels. */
5025 #ifdef JITTER_HAVE_PATCH_IN
5026   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5027 #else
5028   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
5029 #endif // #ifdef JITTER_HAVE_PATCH_IN
5030 
5031   /* Define argument-access macros for ba/fR . */
5032 #ifdef JITTER_HAVE_PATCH_IN
5033   /* Define argument-access macros assuming that fast branches are enabled. */
5034     /* The 0th argument is a "residual" fast label.  Define its
5035        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5036        so that at replication time we know what instruction address to patch in. */
5037 #   define JITTER_ARGF0 0
5038     /* JITTER_ARG0 is intentionally not defined for a fast label. */
5039 
5040 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5041 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5042 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5043 
5044 #else
5045   /* Define argument-access macros assuming that fast branches are disabled. */
5046 #if defined(JITTER_DISPATCH_NO_THREADING)
5047 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
5048     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
5049 #elif defined (JITTER_REPLICATE)
5050 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
5051 #else
5052 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
5053 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5054 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5055 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5056 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5057 #   define JITTER_ARGF0 JITTER_ARGP0
5058 
5059 # endif // #ifdef JITTER_HAVE_PATCH_IN
5060 
5061 #if defined (JITTER_PROFILE_SAMPLE)
5062   JITTER_PROFILE_SAMPLE_UPDATE
5063      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5064       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5065   /* Force the compiler not move sample-profiling instrumentation
5066      beyond this point; this way the actual user code is timed.
5067      This is still not perfect, as residuals are materialised before
5068      we arrive here, but should be adequate at least for slow VM
5069      instructions. */
5070   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5071 #endif
5072 #if defined (JITTER_PROFILE_COUNT)
5073   /* Notice that, differently from the code above, this
5074      instrumentation code *can* be reordered freely: as long as a
5075      VM instruction is counted, the count increment can be placed
5076      anyehere.  Let GCC move this code and possibly achieve better
5077      throughput by exploiting instruction-level parallelism and
5078      therefore approximate more closely a non-profiled build. */
5079   JITTER_PROFILE_COUNT_UPDATE
5080      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5081       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5082 #endif
5083 
5084 /* User-specified code, instruction-beginning-c part: beginning. */
5085 
5086 /* User-specified code, instruction-beginning-c part: end */
5087 
5088 
5089     /* User code for ba/fR . */
5090 #line 3589 "../../libpoke/pvm.jitter"
5091 
5092     JITTER_BRANCH_FAST(JITTER_ARGF0);
5093 
5094     /* End of the user code for ba/fR . */
5095 
5096 /* User-specified code, instruction-end-c part: beginning. */
5097 
5098 /* User-specified code, instruction-end-c part: end */
5099 
5100     /* Undefine the ba/fR argument macros so they can't be used
5101        by mistake in the instruction body coming next. */
5102 #   undef JITTER_SLOW_REGISTER_OFFSET0
5103 #   undef JITTER_ARG0
5104 #   undef JITTER_ARGN0
5105 #   undef JITTER_ARGU0
5106 #   undef JITTER_ARGP0
5107 #   undef JITTER_ARGF0
5108 
5109 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5110 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5111 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5112 
5113   }
5114  JITTER_INSTRUCTION_EPILOG_(ba/fR, ba__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5115 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5116 
5117   JITTER_INSTRUCTION_PROLOG_(bandi, bandi, hot)
5118   {
5119     /* This specialized instruction is not a replacement. */
5120 #   undef JITTER_BRANCH_FAST
5121 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5122 #   undef JITTER_BRANCH_FAST_IF_ZERO
5123 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5124 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5125 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5126 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5127 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5128 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5129 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5130 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5131 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5132 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5133 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5134 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5135 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5136 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5137 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5138 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5139 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5140 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5141 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5142 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5143 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5144 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5145 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5146 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5147 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5148 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5149 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5150 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5151 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5152 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5153 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5154 #   undef JITTER_BRANCH_FAST_IF_AND
5155 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5156 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5157 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5158 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5159 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5160 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5161 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5162 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5163 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5164 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5165 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5166 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5167 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5168 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5169 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5170 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5171 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5172 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5173 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5174 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5175 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5176 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5177 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5178 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5179 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5180 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5181 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5182 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5183 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5184 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       21
5185 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bandi
5186 
5187 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bandi
5188 
5189   /* The residual arity for this instruction does not depend on fast labels. */
5190   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5191 
5192 
5193 #if defined (JITTER_PROFILE_SAMPLE)
5194   JITTER_PROFILE_SAMPLE_UPDATE
5195      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5196       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5197   /* Force the compiler not move sample-profiling instrumentation
5198      beyond this point; this way the actual user code is timed.
5199      This is still not perfect, as residuals are materialised before
5200      we arrive here, but should be adequate at least for slow VM
5201      instructions. */
5202   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5203 #endif
5204 #if defined (JITTER_PROFILE_COUNT)
5205   /* Notice that, differently from the code above, this
5206      instrumentation code *can* be reordered freely: as long as a
5207      VM instruction is counted, the count increment can be placed
5208      anyehere.  Let GCC move this code and possibly achieve better
5209      throughput by exploiting instruction-level parallelism and
5210      therefore approximate more closely a non-profiled build. */
5211   JITTER_PROFILE_COUNT_UPDATE
5212      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5213       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5214 #endif
5215 
5216 /* User-specified code, instruction-beginning-c part: beginning. */
5217 
5218 /* User-specified code, instruction-beginning-c part: end */
5219 
5220 
5221     /* User code for bandi . */
5222 #line 3283 "../../libpoke/pvm.jitter"
5223 
5224     PVM_BINOP (INT, INT, INT, &);
5225 
5226     /* End of the user code for bandi . */
5227 
5228 /* User-specified code, instruction-end-c part: beginning. */
5229 
5230 /* User-specified code, instruction-end-c part: end */
5231 
5232     /* Undefine the bandi argument macros so they can't be used
5233        by mistake in the instruction body coming next. */
5234 
5235 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5236 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5237 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5238 
5239   }
5240  JITTER_INSTRUCTION_EPILOG_(bandi, bandi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5241 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5242 
5243   JITTER_INSTRUCTION_PROLOG_(bandiu, bandiu, hot)
5244   {
5245     /* This specialized instruction is not a replacement. */
5246 #   undef JITTER_BRANCH_FAST
5247 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5248 #   undef JITTER_BRANCH_FAST_IF_ZERO
5249 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5250 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5251 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5252 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5253 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5254 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5255 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5256 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5257 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5258 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5259 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5260 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5261 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5262 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5263 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5264 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5265 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5266 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5267 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5268 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5269 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5270 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5271 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5272 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5273 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5274 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5275 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5276 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5277 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5278 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5279 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5280 #   undef JITTER_BRANCH_FAST_IF_AND
5281 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5282 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5283 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5284 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5285 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5286 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5287 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5288 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5289 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5290 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5291 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5292 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5293 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5294 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5295 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5296 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5297 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5298 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5299 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5300 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5301 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5302 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5303 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5304 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5305 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5306 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5307 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5308 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5309 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5310 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       22
5311 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bandiu
5312 
5313 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bandiu
5314 
5315   /* The residual arity for this instruction does not depend on fast labels. */
5316   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5317 
5318 
5319 #if defined (JITTER_PROFILE_SAMPLE)
5320   JITTER_PROFILE_SAMPLE_UPDATE
5321      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5322       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5323   /* Force the compiler not move sample-profiling instrumentation
5324      beyond this point; this way the actual user code is timed.
5325      This is still not perfect, as residuals are materialised before
5326      we arrive here, but should be adequate at least for slow VM
5327      instructions. */
5328   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5329 #endif
5330 #if defined (JITTER_PROFILE_COUNT)
5331   /* Notice that, differently from the code above, this
5332      instrumentation code *can* be reordered freely: as long as a
5333      VM instruction is counted, the count increment can be placed
5334      anyehere.  Let GCC move this code and possibly achieve better
5335      throughput by exploiting instruction-level parallelism and
5336      therefore approximate more closely a non-profiled build. */
5337   JITTER_PROFILE_COUNT_UPDATE
5338      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5339       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5340 #endif
5341 
5342 /* User-specified code, instruction-beginning-c part: beginning. */
5343 
5344 /* User-specified code, instruction-beginning-c part: end */
5345 
5346 
5347     /* User code for bandiu . */
5348 #line 3296 "../../libpoke/pvm.jitter"
5349 
5350     PVM_BINOP (UINT, UINT, UINT, &);
5351 
5352     /* End of the user code for bandiu . */
5353 
5354 /* User-specified code, instruction-end-c part: beginning. */
5355 
5356 /* User-specified code, instruction-end-c part: end */
5357 
5358     /* Undefine the bandiu argument macros so they can't be used
5359        by mistake in the instruction body coming next. */
5360 
5361 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5362 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5363 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5364 
5365   }
5366  JITTER_INSTRUCTION_EPILOG_(bandiu, bandiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5367 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5368 
5369   JITTER_INSTRUCTION_PROLOG_(bandl, bandl, hot)
5370   {
5371     /* This specialized instruction is not a replacement. */
5372 #   undef JITTER_BRANCH_FAST
5373 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5374 #   undef JITTER_BRANCH_FAST_IF_ZERO
5375 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5376 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5377 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5378 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5379 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5380 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5381 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5382 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5383 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5384 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5385 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5386 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5387 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5388 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5389 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5390 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5391 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5392 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5393 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5394 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5395 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5396 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5397 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5398 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5399 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5400 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5401 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5402 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5403 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5404 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5405 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5406 #   undef JITTER_BRANCH_FAST_IF_AND
5407 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5408 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5409 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5410 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5411 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5412 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5413 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5414 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5415 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5416 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5417 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5418 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5419 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5420 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5421 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5422 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5423 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5424 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5425 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5426 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5427 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5428 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5429 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5430 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5431 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5432 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5433 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5434 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5435 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5436 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       23
5437 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bandl
5438 
5439 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bandl
5440 
5441   /* The residual arity for this instruction does not depend on fast labels. */
5442   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5443 
5444 
5445 #if defined (JITTER_PROFILE_SAMPLE)
5446   JITTER_PROFILE_SAMPLE_UPDATE
5447      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5448       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5449   /* Force the compiler not move sample-profiling instrumentation
5450      beyond this point; this way the actual user code is timed.
5451      This is still not perfect, as residuals are materialised before
5452      we arrive here, but should be adequate at least for slow VM
5453      instructions. */
5454   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5455 #endif
5456 #if defined (JITTER_PROFILE_COUNT)
5457   /* Notice that, differently from the code above, this
5458      instrumentation code *can* be reordered freely: as long as a
5459      VM instruction is counted, the count increment can be placed
5460      anyehere.  Let GCC move this code and possibly achieve better
5461      throughput by exploiting instruction-level parallelism and
5462      therefore approximate more closely a non-profiled build. */
5463   JITTER_PROFILE_COUNT_UPDATE
5464      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5465       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5466 #endif
5467 
5468 /* User-specified code, instruction-beginning-c part: beginning. */
5469 
5470 /* User-specified code, instruction-beginning-c part: end */
5471 
5472 
5473     /* User code for bandl . */
5474 #line 3308 "../../libpoke/pvm.jitter"
5475 
5476     PVM_BINOP (LONG, LONG, LONG, &);
5477 
5478     /* End of the user code for bandl . */
5479 
5480 /* User-specified code, instruction-end-c part: beginning. */
5481 
5482 /* User-specified code, instruction-end-c part: end */
5483 
5484     /* Undefine the bandl argument macros so they can't be used
5485        by mistake in the instruction body coming next. */
5486 
5487 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5488 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5489 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5490 
5491   }
5492  JITTER_INSTRUCTION_EPILOG_(bandl, bandl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5493 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5494 
5495   JITTER_INSTRUCTION_PROLOG_(bandlu, bandlu, hot)
5496   {
5497     /* This specialized instruction is not a replacement. */
5498 #   undef JITTER_BRANCH_FAST
5499 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5500 #   undef JITTER_BRANCH_FAST_IF_ZERO
5501 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5502 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5503 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5504 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5505 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5506 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5507 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5508 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5509 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5510 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5511 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5512 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5513 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5514 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5515 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5516 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5517 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5518 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5519 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5520 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5521 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5522 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5523 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5524 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5525 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5526 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5527 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5528 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5529 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5530 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5531 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5532 #   undef JITTER_BRANCH_FAST_IF_AND
5533 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5534 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5535 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5536 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5537 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5538 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5539 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5540 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5541 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5542 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5543 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5544 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5545 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5546 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5547 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5548 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5549 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5550 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5551 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5552 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5553 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5554 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5555 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5556 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5557 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5558 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5559 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5560 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5561 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5562 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       24
5563 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bandlu
5564 
5565 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bandlu
5566 
5567   /* The residual arity for this instruction does not depend on fast labels. */
5568   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5569 
5570 
5571 #if defined (JITTER_PROFILE_SAMPLE)
5572   JITTER_PROFILE_SAMPLE_UPDATE
5573      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5574       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5575   /* Force the compiler not move sample-profiling instrumentation
5576      beyond this point; this way the actual user code is timed.
5577      This is still not perfect, as residuals are materialised before
5578      we arrive here, but should be adequate at least for slow VM
5579      instructions. */
5580   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5581 #endif
5582 #if defined (JITTER_PROFILE_COUNT)
5583   /* Notice that, differently from the code above, this
5584      instrumentation code *can* be reordered freely: as long as a
5585      VM instruction is counted, the count increment can be placed
5586      anyehere.  Let GCC move this code and possibly achieve better
5587      throughput by exploiting instruction-level parallelism and
5588      therefore approximate more closely a non-profiled build. */
5589   JITTER_PROFILE_COUNT_UPDATE
5590      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5591       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5592 #endif
5593 
5594 /* User-specified code, instruction-beginning-c part: beginning. */
5595 
5596 /* User-specified code, instruction-beginning-c part: end */
5597 
5598 
5599     /* User code for bandlu . */
5600 #line 3321 "../../libpoke/pvm.jitter"
5601 
5602     PVM_BINOP (ULONG, ULONG, ULONG, &);
5603 
5604     /* End of the user code for bandlu . */
5605 
5606 /* User-specified code, instruction-end-c part: beginning. */
5607 
5608 /* User-specified code, instruction-end-c part: end */
5609 
5610     /* Undefine the bandlu argument macros so they can't be used
5611        by mistake in the instruction body coming next. */
5612 
5613 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5614 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5615 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5616 
5617   }
5618  JITTER_INSTRUCTION_EPILOG_(bandlu, bandlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5619 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5620 
5621   JITTER_INSTRUCTION_PROLOG_(beghl, beghl, hot)
5622   {
5623     /* This specialized instruction is not a replacement. */
5624 #   undef JITTER_BRANCH_FAST
5625 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5626 #   undef JITTER_BRANCH_FAST_IF_ZERO
5627 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5628 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5629 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5630 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5631 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5632 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5633 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5634 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5635 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5636 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5637 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5638 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5639 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5640 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5641 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5642 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5643 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5644 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5645 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5646 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5647 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5648 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5649 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5650 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5651 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5652 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5653 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5654 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5655 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5656 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5657 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5658 #   undef JITTER_BRANCH_FAST_IF_AND
5659 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5660 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5661 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5662 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5663 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5664 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5665 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5666 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5667 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5668 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5669 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5670 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5671 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5672 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5673 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5674 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5675 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5676 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5677 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5678 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5679 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5680 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5681 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5682 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5683 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5684 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5685 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5686 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5687 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5688 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       25
5689 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         beghl
5690 
5691 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME beghl
5692 
5693   /* The residual arity for this instruction does not depend on fast labels. */
5694   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5695 
5696 
5697 #if defined (JITTER_PROFILE_SAMPLE)
5698   JITTER_PROFILE_SAMPLE_UPDATE
5699      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5700       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5701   /* Force the compiler not move sample-profiling instrumentation
5702      beyond this point; this way the actual user code is timed.
5703      This is still not perfect, as residuals are materialised before
5704      we arrive here, but should be adequate at least for slow VM
5705      instructions. */
5706   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5707 #endif
5708 #if defined (JITTER_PROFILE_COUNT)
5709   /* Notice that, differently from the code above, this
5710      instrumentation code *can* be reordered freely: as long as a
5711      VM instruction is counted, the count increment can be placed
5712      anyehere.  Let GCC move this code and possibly achieve better
5713      throughput by exploiting instruction-level parallelism and
5714      therefore approximate more closely a non-profiled build. */
5715   JITTER_PROFILE_COUNT_UPDATE
5716      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5717       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5718 #endif
5719 
5720 /* User-specified code, instruction-beginning-c part: beginning. */
5721 
5722 /* User-specified code, instruction-beginning-c part: end */
5723 
5724 
5725     /* User code for beghl . */
5726 #line 1847 "../../libpoke/pvm.jitter"
5727 
5728     char *url = PVM_VAL_STR (JITTER_UNDER_TOP_STACK ());
5729     char *id = PVM_VAL_STR (JITTER_TOP_STACK ());
5730 
5731     JITTER_DROP_STACK ();
5732     JITTER_DROP_STACK ();
5733     pk_term_hyperlink (url, id);
5734 
5735     /* End of the user code for beghl . */
5736 
5737 /* User-specified code, instruction-end-c part: beginning. */
5738 
5739 /* User-specified code, instruction-end-c part: end */
5740 
5741     /* Undefine the beghl argument macros so they can't be used
5742        by mistake in the instruction body coming next. */
5743 
5744 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5745 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5746 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5747 
5748   }
5749  JITTER_INSTRUCTION_EPILOG_(beghl, beghl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5750 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5751 
5752   JITTER_INSTRUCTION_PROLOG_(begsc, begsc, hot)
5753   {
5754     /* This specialized instruction is not a replacement. */
5755 #   undef JITTER_BRANCH_FAST
5756 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5757 #   undef JITTER_BRANCH_FAST_IF_ZERO
5758 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5759 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5760 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5761 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5762 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5763 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5764 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5765 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5766 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5767 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5768 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5769 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5770 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5771 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5772 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5773 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5774 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5775 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5776 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5777 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5778 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5779 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5780 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5781 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5782 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5783 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5784 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5785 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5786 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5787 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5788 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5789 #   undef JITTER_BRANCH_FAST_IF_AND
5790 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5791 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5792 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5793 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5794 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5795 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5796 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5797 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5798 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5799 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5800 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5801 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5802 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5803 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5804 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5805 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5806 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5807 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5808 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5809 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5810 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5811 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5812 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5813 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5814 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5815 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5816 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5817 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5818 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5819 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       26
5820 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         begsc
5821 
5822 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME begsc
5823 
5824   /* The residual arity for this instruction does not depend on fast labels. */
5825   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5826 
5827 
5828 #if defined (JITTER_PROFILE_SAMPLE)
5829   JITTER_PROFILE_SAMPLE_UPDATE
5830      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5831       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5832   /* Force the compiler not move sample-profiling instrumentation
5833      beyond this point; this way the actual user code is timed.
5834      This is still not perfect, as residuals are materialised before
5835      we arrive here, but should be adequate at least for slow VM
5836      instructions. */
5837   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5838 #endif
5839 #if defined (JITTER_PROFILE_COUNT)
5840   /* Notice that, differently from the code above, this
5841      instrumentation code *can* be reordered freely: as long as a
5842      VM instruction is counted, the count increment can be placed
5843      anyehere.  Let GCC move this code and possibly achieve better
5844      throughput by exploiting instruction-level parallelism and
5845      therefore approximate more closely a non-profiled build. */
5846   JITTER_PROFILE_COUNT_UPDATE
5847      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5848       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5849 #endif
5850 
5851 /* User-specified code, instruction-beginning-c part: beginning. */
5852 
5853 /* User-specified code, instruction-beginning-c part: end */
5854 
5855 
5856     /* User code for begsc . */
5857 #line 1885 "../../libpoke/pvm.jitter"
5858 
5859     pk_term_class (PVM_VAL_STR (JITTER_TOP_STACK ()));
5860     JITTER_DROP_STACK ();
5861 
5862     /* End of the user code for begsc . */
5863 
5864 /* User-specified code, instruction-end-c part: beginning. */
5865 
5866 /* User-specified code, instruction-end-c part: end */
5867 
5868     /* Undefine the begsc argument macros so they can't be used
5869        by mistake in the instruction body coming next. */
5870 
5871 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5872 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5873 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5874 
5875   }
5876  JITTER_INSTRUCTION_EPILOG_(begsc, begsc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5877 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5878 
5879   JITTER_INSTRUCTION_PROLOG_(bn/fR, bn__fR, hot)
5880   {
5881     /* This specialized instruction is not a replacement. */
5882 #   undef JITTER_BRANCH_FAST
5883 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5884 #   undef JITTER_BRANCH_FAST_IF_ZERO
5885 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5886 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5887 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5888 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5889 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5890 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5891 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5892 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5893 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5894 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5895 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5896 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5897 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5898 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5899 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5900 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5901 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5902 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5903 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5904 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5905 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5906 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5907 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5908 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5909 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5910 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5911 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5912 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5913 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5914 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5915 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5916 #   undef JITTER_BRANCH_FAST_IF_AND
5917 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5918 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5919 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5920 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5921 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5922 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5923 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5924 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5925 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5926 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5927 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5928 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5929 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5930 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5931 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5932 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5933 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5934 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5935 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5936 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5937 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5938 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5939 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5940 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5941 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5942 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5943 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5944 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5945 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5946 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       27
5947 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bn/fR
5948 
5949 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bn__fR
5950 
5951   /* The residual arity varies depending on whether we have fast labels. */
5952 #ifdef JITTER_HAVE_PATCH_IN
5953   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5954 #else
5955   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
5956 #endif // #ifdef JITTER_HAVE_PATCH_IN
5957 
5958   /* Define argument-access macros for bn/fR . */
5959 #ifdef JITTER_HAVE_PATCH_IN
5960   /* Define argument-access macros assuming that fast branches are enabled. */
5961     /* The 0th argument is a "residual" fast label.  Define its
5962        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5963        so that at replication time we know what instruction address to patch in. */
5964 #   define JITTER_ARGF0 0
5965     /* JITTER_ARG0 is intentionally not defined for a fast label. */
5966 
5967 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5968 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5969 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5970 
5971 #else
5972   /* Define argument-access macros assuming that fast branches are disabled. */
5973 #if defined(JITTER_DISPATCH_NO_THREADING)
5974 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
5975     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
5976 #elif defined (JITTER_REPLICATE)
5977 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
5978 #else
5979 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
5980 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5981 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5982 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5983 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5984 #   define JITTER_ARGF0 JITTER_ARGP0
5985 
5986 # endif // #ifdef JITTER_HAVE_PATCH_IN
5987 
5988 #if defined (JITTER_PROFILE_SAMPLE)
5989   JITTER_PROFILE_SAMPLE_UPDATE
5990      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5991       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5992   /* Force the compiler not move sample-profiling instrumentation
5993      beyond this point; this way the actual user code is timed.
5994      This is still not perfect, as residuals are materialised before
5995      we arrive here, but should be adequate at least for slow VM
5996      instructions. */
5997   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5998 #endif
5999 #if defined (JITTER_PROFILE_COUNT)
6000   /* Notice that, differently from the code above, this
6001      instrumentation code *can* be reordered freely: as long as a
6002      VM instruction is counted, the count increment can be placed
6003      anyehere.  Let GCC move this code and possibly achieve better
6004      throughput by exploiting instruction-level parallelism and
6005      therefore approximate more closely a non-profiled build. */
6006   JITTER_PROFILE_COUNT_UPDATE
6007      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6008       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6009 #endif
6010 
6011 /* User-specified code, instruction-beginning-c part: beginning. */
6012 
6013 /* User-specified code, instruction-beginning-c part: end */
6014 
6015 
6016     /* User code for bn/fR . */
6017 #line 3602 "../../libpoke/pvm.jitter"
6018 
6019     pvm_val tmp = JITTER_TOP_STACK ();
6020     JITTER_BRANCH_FAST_IF_ZERO (tmp != PVM_NULL, JITTER_ARGF0);
6021 
6022     /* End of the user code for bn/fR . */
6023 
6024 /* User-specified code, instruction-end-c part: beginning. */
6025 
6026 /* User-specified code, instruction-end-c part: end */
6027 
6028     /* Undefine the bn/fR argument macros so they can't be used
6029        by mistake in the instruction body coming next. */
6030 #   undef JITTER_SLOW_REGISTER_OFFSET0
6031 #   undef JITTER_ARG0
6032 #   undef JITTER_ARGN0
6033 #   undef JITTER_ARGU0
6034 #   undef JITTER_ARGP0
6035 #   undef JITTER_ARGF0
6036 
6037 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6038 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6039 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6040 
6041   }
6042  JITTER_INSTRUCTION_EPILOG_(bn/fR, bn__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6043 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6044 
6045   JITTER_INSTRUCTION_PROLOG_(bnn/fR, bnn__fR, hot)
6046   {
6047     /* This specialized instruction is not a replacement. */
6048 #   undef JITTER_BRANCH_FAST
6049 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6050 #   undef JITTER_BRANCH_FAST_IF_ZERO
6051 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6052 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6053 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6054 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6055 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6056 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6057 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6058 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6059 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6060 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6061 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6062 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6063 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6064 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6065 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6066 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6067 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6068 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6069 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6070 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6071 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6072 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6073 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6074 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6075 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6076 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6077 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6078 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6079 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6080 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6081 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6082 #   undef JITTER_BRANCH_FAST_IF_AND
6083 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6084 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6085 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6086 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6087 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6088 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6089 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6090 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6091 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6092 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6093 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6094 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6095 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6096 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6097 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6098 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6099 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6100 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6101 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6102 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6103 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6104 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6105 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6106 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6107 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6108 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6109 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6110 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6111 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6112 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       28
6113 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnn/fR
6114 
6115 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnn__fR
6116 
6117   /* The residual arity varies depending on whether we have fast labels. */
6118 #ifdef JITTER_HAVE_PATCH_IN
6119   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6120 #else
6121   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
6122 #endif // #ifdef JITTER_HAVE_PATCH_IN
6123 
6124   /* Define argument-access macros for bnn/fR . */
6125 #ifdef JITTER_HAVE_PATCH_IN
6126   /* Define argument-access macros assuming that fast branches are enabled. */
6127     /* The 0th argument is a "residual" fast label.  Define its
6128        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
6129        so that at replication time we know what instruction address to patch in. */
6130 #   define JITTER_ARGF0 0
6131     /* JITTER_ARG0 is intentionally not defined for a fast label. */
6132 
6133 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6134 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6135 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6136 
6137 #else
6138   /* Define argument-access macros assuming that fast branches are disabled. */
6139 #if defined(JITTER_DISPATCH_NO_THREADING)
6140 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
6141     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
6142 #elif defined (JITTER_REPLICATE)
6143 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
6144 #else
6145 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
6146 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6147 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6148 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6149 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6150 #   define JITTER_ARGF0 JITTER_ARGP0
6151 
6152 # endif // #ifdef JITTER_HAVE_PATCH_IN
6153 
6154 #if defined (JITTER_PROFILE_SAMPLE)
6155   JITTER_PROFILE_SAMPLE_UPDATE
6156      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6157       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6158   /* Force the compiler not move sample-profiling instrumentation
6159      beyond this point; this way the actual user code is timed.
6160      This is still not perfect, as residuals are materialised before
6161      we arrive here, but should be adequate at least for slow VM
6162      instructions. */
6163   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6164 #endif
6165 #if defined (JITTER_PROFILE_COUNT)
6166   /* Notice that, differently from the code above, this
6167      instrumentation code *can* be reordered freely: as long as a
6168      VM instruction is counted, the count increment can be placed
6169      anyehere.  Let GCC move this code and possibly achieve better
6170      throughput by exploiting instruction-level parallelism and
6171      therefore approximate more closely a non-profiled build. */
6172   JITTER_PROFILE_COUNT_UPDATE
6173      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6174       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6175 #endif
6176 
6177 /* User-specified code, instruction-beginning-c part: beginning. */
6178 
6179 /* User-specified code, instruction-beginning-c part: end */
6180 
6181 
6182     /* User code for bnn/fR . */
6183 #line 3616 "../../libpoke/pvm.jitter"
6184 
6185     pvm_val tmp = JITTER_TOP_STACK ();
6186     JITTER_BRANCH_FAST_IF_ZERO (tmp == PVM_NULL, JITTER_ARGF0);
6187 
6188     /* End of the user code for bnn/fR . */
6189 
6190 /* User-specified code, instruction-end-c part: beginning. */
6191 
6192 /* User-specified code, instruction-end-c part: end */
6193 
6194     /* Undefine the bnn/fR argument macros so they can't be used
6195        by mistake in the instruction body coming next. */
6196 #   undef JITTER_SLOW_REGISTER_OFFSET0
6197 #   undef JITTER_ARG0
6198 #   undef JITTER_ARGN0
6199 #   undef JITTER_ARGU0
6200 #   undef JITTER_ARGP0
6201 #   undef JITTER_ARGF0
6202 
6203 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6204 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6205 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6206 
6207   }
6208  JITTER_INSTRUCTION_EPILOG_(bnn/fR, bnn__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6209 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6210 
6211   JITTER_INSTRUCTION_PROLOG_(bnoti, bnoti, hot)
6212   {
6213     /* This specialized instruction is not a replacement. */
6214 #   undef JITTER_BRANCH_FAST
6215 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6216 #   undef JITTER_BRANCH_FAST_IF_ZERO
6217 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6218 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6219 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6220 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6221 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6222 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6223 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6224 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6225 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6226 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6227 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6228 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6229 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6230 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6231 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6232 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6233 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6234 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6235 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6236 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6237 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6238 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6239 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6240 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6241 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6242 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6243 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6244 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6245 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6246 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6247 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6248 #   undef JITTER_BRANCH_FAST_IF_AND
6249 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6250 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6251 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6252 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6253 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6254 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6255 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6256 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6257 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6258 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6259 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6260 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6261 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6262 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6263 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6264 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6265 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6266 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6267 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6268 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6269 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6270 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6271 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6272 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6273 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6274 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6275 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6276 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6277 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6278 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       29
6279 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnoti
6280 
6281 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnoti
6282 
6283   /* The residual arity for this instruction does not depend on fast labels. */
6284   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6285 
6286 
6287 #if defined (JITTER_PROFILE_SAMPLE)
6288   JITTER_PROFILE_SAMPLE_UPDATE
6289      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6290       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6291   /* Force the compiler not move sample-profiling instrumentation
6292      beyond this point; this way the actual user code is timed.
6293      This is still not perfect, as residuals are materialised before
6294      we arrive here, but should be adequate at least for slow VM
6295      instructions. */
6296   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6297 #endif
6298 #if defined (JITTER_PROFILE_COUNT)
6299   /* Notice that, differently from the code above, this
6300      instrumentation code *can* be reordered freely: as long as a
6301      VM instruction is counted, the count increment can be placed
6302      anyehere.  Let GCC move this code and possibly achieve better
6303      throughput by exploiting instruction-level parallelism and
6304      therefore approximate more closely a non-profiled build. */
6305   JITTER_PROFILE_COUNT_UPDATE
6306      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6307       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6308 #endif
6309 
6310 /* User-specified code, instruction-beginning-c part: beginning. */
6311 
6312 /* User-specified code, instruction-beginning-c part: end */
6313 
6314 
6315     /* User code for bnoti . */
6316 #line 3333 "../../libpoke/pvm.jitter"
6317 
6318     PVM_UNOP (INT, INT, int, ~);
6319 
6320     /* End of the user code for bnoti . */
6321 
6322 /* User-specified code, instruction-end-c part: beginning. */
6323 
6324 /* User-specified code, instruction-end-c part: end */
6325 
6326     /* Undefine the bnoti argument macros so they can't be used
6327        by mistake in the instruction body coming next. */
6328 
6329 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6330 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6331 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6332 
6333   }
6334  JITTER_INSTRUCTION_EPILOG_(bnoti, bnoti, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6335 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6336 
6337   JITTER_INSTRUCTION_PROLOG_(bnotiu, bnotiu, hot)
6338   {
6339     /* This specialized instruction is not a replacement. */
6340 #   undef JITTER_BRANCH_FAST
6341 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6342 #   undef JITTER_BRANCH_FAST_IF_ZERO
6343 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6344 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6345 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6346 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6347 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6348 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6349 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6350 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6351 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6352 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6353 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6354 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6355 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6356 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6357 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6358 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6359 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6360 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6361 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6362 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6363 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6364 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6365 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6366 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6367 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6368 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6369 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6370 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6371 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6372 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6373 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6374 #   undef JITTER_BRANCH_FAST_IF_AND
6375 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6376 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6377 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6378 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6379 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6380 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6381 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6382 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6383 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6384 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6385 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6386 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6387 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6388 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6389 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6390 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6391 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6392 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6393 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6394 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6395 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6396 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6397 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6398 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6399 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6400 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6401 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6402 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6403 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6404 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       30
6405 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnotiu
6406 
6407 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnotiu
6408 
6409   /* The residual arity for this instruction does not depend on fast labels. */
6410   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6411 
6412 
6413 #if defined (JITTER_PROFILE_SAMPLE)
6414   JITTER_PROFILE_SAMPLE_UPDATE
6415      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6416       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6417   /* Force the compiler not move sample-profiling instrumentation
6418      beyond this point; this way the actual user code is timed.
6419      This is still not perfect, as residuals are materialised before
6420      we arrive here, but should be adequate at least for slow VM
6421      instructions. */
6422   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6423 #endif
6424 #if defined (JITTER_PROFILE_COUNT)
6425   /* Notice that, differently from the code above, this
6426      instrumentation code *can* be reordered freely: as long as a
6427      VM instruction is counted, the count increment can be placed
6428      anyehere.  Let GCC move this code and possibly achieve better
6429      throughput by exploiting instruction-level parallelism and
6430      therefore approximate more closely a non-profiled build. */
6431   JITTER_PROFILE_COUNT_UPDATE
6432      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6433       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6434 #endif
6435 
6436 /* User-specified code, instruction-beginning-c part: beginning. */
6437 
6438 /* User-specified code, instruction-beginning-c part: end */
6439 
6440 
6441     /* User code for bnotiu . */
6442 #line 3346 "../../libpoke/pvm.jitter"
6443 
6444     PVM_UNOP (UINT, UINT, uint, ~);
6445 
6446     /* End of the user code for bnotiu . */
6447 
6448 /* User-specified code, instruction-end-c part: beginning. */
6449 
6450 /* User-specified code, instruction-end-c part: end */
6451 
6452     /* Undefine the bnotiu argument macros so they can't be used
6453        by mistake in the instruction body coming next. */
6454 
6455 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6456 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6457 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6458 
6459   }
6460  JITTER_INSTRUCTION_EPILOG_(bnotiu, bnotiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6461 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6462 
6463   JITTER_INSTRUCTION_PROLOG_(bnotl, bnotl, hot)
6464   {
6465     /* This specialized instruction is not a replacement. */
6466 #   undef JITTER_BRANCH_FAST
6467 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6468 #   undef JITTER_BRANCH_FAST_IF_ZERO
6469 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6470 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6471 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6472 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6473 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6474 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6475 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6476 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6477 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6478 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6479 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6480 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6481 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6482 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6483 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6484 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6485 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6486 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6487 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6488 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6489 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6490 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6491 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6492 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6493 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6494 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6495 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6496 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6497 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6498 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6499 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6500 #   undef JITTER_BRANCH_FAST_IF_AND
6501 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6502 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6503 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6504 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6505 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6506 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6507 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6508 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6509 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6510 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6511 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6512 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6513 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6514 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6515 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6516 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6517 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6518 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6519 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6520 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6521 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6522 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6523 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6524 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6525 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6526 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6527 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6528 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6529 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6530 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       31
6531 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnotl
6532 
6533 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnotl
6534 
6535   /* The residual arity for this instruction does not depend on fast labels. */
6536   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6537 
6538 
6539 #if defined (JITTER_PROFILE_SAMPLE)
6540   JITTER_PROFILE_SAMPLE_UPDATE
6541      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6542       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6543   /* Force the compiler not move sample-profiling instrumentation
6544      beyond this point; this way the actual user code is timed.
6545      This is still not perfect, as residuals are materialised before
6546      we arrive here, but should be adequate at least for slow VM
6547      instructions. */
6548   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6549 #endif
6550 #if defined (JITTER_PROFILE_COUNT)
6551   /* Notice that, differently from the code above, this
6552      instrumentation code *can* be reordered freely: as long as a
6553      VM instruction is counted, the count increment can be placed
6554      anyehere.  Let GCC move this code and possibly achieve better
6555      throughput by exploiting instruction-level parallelism and
6556      therefore approximate more closely a non-profiled build. */
6557   JITTER_PROFILE_COUNT_UPDATE
6558      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6559       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6560 #endif
6561 
6562 /* User-specified code, instruction-beginning-c part: beginning. */
6563 
6564 /* User-specified code, instruction-beginning-c part: end */
6565 
6566 
6567     /* User code for bnotl . */
6568 #line 3358 "../../libpoke/pvm.jitter"
6569 
6570     PVM_UNOP (LONG, LONG, long, ~);
6571 
6572     /* End of the user code for bnotl . */
6573 
6574 /* User-specified code, instruction-end-c part: beginning. */
6575 
6576 /* User-specified code, instruction-end-c part: end */
6577 
6578     /* Undefine the bnotl argument macros so they can't be used
6579        by mistake in the instruction body coming next. */
6580 
6581 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6582 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6583 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6584 
6585   }
6586  JITTER_INSTRUCTION_EPILOG_(bnotl, bnotl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6587 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6588 
6589   JITTER_INSTRUCTION_PROLOG_(bnotlu, bnotlu, hot)
6590   {
6591     /* This specialized instruction is not a replacement. */
6592 #   undef JITTER_BRANCH_FAST
6593 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6594 #   undef JITTER_BRANCH_FAST_IF_ZERO
6595 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6596 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6597 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6598 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6599 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6600 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6601 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6602 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6603 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6604 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6605 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6606 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6607 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6608 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6609 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6610 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6611 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6612 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6613 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6614 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6615 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6616 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6617 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6618 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6619 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6620 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6621 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6622 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6623 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6624 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6625 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6626 #   undef JITTER_BRANCH_FAST_IF_AND
6627 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6628 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6629 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6630 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6631 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6632 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6633 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6634 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6635 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6636 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6637 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6638 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6639 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6640 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6641 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6642 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6643 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6644 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6645 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6646 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6647 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6648 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6649 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6650 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6651 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6652 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6653 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6654 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6655 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6656 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       32
6657 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnotlu
6658 
6659 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnotlu
6660 
6661   /* The residual arity for this instruction does not depend on fast labels. */
6662   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6663 
6664 
6665 #if defined (JITTER_PROFILE_SAMPLE)
6666   JITTER_PROFILE_SAMPLE_UPDATE
6667      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6668       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6669   /* Force the compiler not move sample-profiling instrumentation
6670      beyond this point; this way the actual user code is timed.
6671      This is still not perfect, as residuals are materialised before
6672      we arrive here, but should be adequate at least for slow VM
6673      instructions. */
6674   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6675 #endif
6676 #if defined (JITTER_PROFILE_COUNT)
6677   /* Notice that, differently from the code above, this
6678      instrumentation code *can* be reordered freely: as long as a
6679      VM instruction is counted, the count increment can be placed
6680      anyehere.  Let GCC move this code and possibly achieve better
6681      throughput by exploiting instruction-level parallelism and
6682      therefore approximate more closely a non-profiled build. */
6683   JITTER_PROFILE_COUNT_UPDATE
6684      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6685       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6686 #endif
6687 
6688 /* User-specified code, instruction-beginning-c part: beginning. */
6689 
6690 /* User-specified code, instruction-beginning-c part: end */
6691 
6692 
6693     /* User code for bnotlu . */
6694 #line 3370 "../../libpoke/pvm.jitter"
6695 
6696     PVM_UNOP (ULONG, ULONG, ulong, ~);
6697 
6698     /* End of the user code for bnotlu . */
6699 
6700 /* User-specified code, instruction-end-c part: beginning. */
6701 
6702 /* User-specified code, instruction-end-c part: end */
6703 
6704     /* Undefine the bnotlu argument macros so they can't be used
6705        by mistake in the instruction body coming next. */
6706 
6707 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6708 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6709 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6710 
6711   }
6712  JITTER_INSTRUCTION_EPILOG_(bnotlu, bnotlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6713 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6714 
6715   JITTER_INSTRUCTION_PROLOG_(bnzi/fR, bnzi__fR, hot)
6716   {
6717     /* This specialized instruction is not a replacement. */
6718 #   undef JITTER_BRANCH_FAST
6719 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6720 #   undef JITTER_BRANCH_FAST_IF_ZERO
6721 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6722 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6723 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6724 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6725 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6726 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6727 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6728 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6729 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6730 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6731 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6732 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6733 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6734 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6735 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6736 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6737 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6738 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6739 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6740 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6741 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6742 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6743 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6744 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6745 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6746 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6747 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6748 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6749 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6750 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6751 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6752 #   undef JITTER_BRANCH_FAST_IF_AND
6753 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6754 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6755 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6756 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6757 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6758 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6759 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6760 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6761 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6762 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6763 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6764 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6765 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6766 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6767 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6768 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6769 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6770 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6771 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6772 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6773 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6774 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6775 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6776 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6777 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6778 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6779 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6780 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6781 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6782 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       33
6783 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnzi/fR
6784 
6785 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnzi__fR
6786 
6787   /* The residual arity varies depending on whether we have fast labels. */
6788 #ifdef JITTER_HAVE_PATCH_IN
6789   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6790 #else
6791   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
6792 #endif // #ifdef JITTER_HAVE_PATCH_IN
6793 
6794   /* Define argument-access macros for bnzi/fR . */
6795 #ifdef JITTER_HAVE_PATCH_IN
6796   /* Define argument-access macros assuming that fast branches are enabled. */
6797     /* The 0th argument is a "residual" fast label.  Define its
6798        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
6799        so that at replication time we know what instruction address to patch in. */
6800 #   define JITTER_ARGF0 0
6801     /* JITTER_ARG0 is intentionally not defined for a fast label. */
6802 
6803 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6804 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6805 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6806 
6807 #else
6808   /* Define argument-access macros assuming that fast branches are disabled. */
6809 #if defined(JITTER_DISPATCH_NO_THREADING)
6810 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
6811     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
6812 #elif defined (JITTER_REPLICATE)
6813 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
6814 #else
6815 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
6816 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6817 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6818 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6819 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6820 #   define JITTER_ARGF0 JITTER_ARGP0
6821 
6822 # endif // #ifdef JITTER_HAVE_PATCH_IN
6823 
6824 #if defined (JITTER_PROFILE_SAMPLE)
6825   JITTER_PROFILE_SAMPLE_UPDATE
6826      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6827       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6828   /* Force the compiler not move sample-profiling instrumentation
6829      beyond this point; this way the actual user code is timed.
6830      This is still not perfect, as residuals are materialised before
6831      we arrive here, but should be adequate at least for slow VM
6832      instructions. */
6833   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6834 #endif
6835 #if defined (JITTER_PROFILE_COUNT)
6836   /* Notice that, differently from the code above, this
6837      instrumentation code *can* be reordered freely: as long as a
6838      VM instruction is counted, the count increment can be placed
6839      anyehere.  Let GCC move this code and possibly achieve better
6840      throughput by exploiting instruction-level parallelism and
6841      therefore approximate more closely a non-profiled build. */
6842   JITTER_PROFILE_COUNT_UPDATE
6843      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6844       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6845 #endif
6846 
6847 /* User-specified code, instruction-beginning-c part: beginning. */
6848 
6849 /* User-specified code, instruction-beginning-c part: end */
6850 
6851 
6852     /* User code for bnzi/fR . */
6853 #line 3686 "../../libpoke/pvm.jitter"
6854 
6855     pvm_val tmp = JITTER_TOP_STACK ();
6856     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_INT (tmp), JITTER_ARGF0);
6857 
6858     /* End of the user code for bnzi/fR . */
6859 
6860 /* User-specified code, instruction-end-c part: beginning. */
6861 
6862 /* User-specified code, instruction-end-c part: end */
6863 
6864     /* Undefine the bnzi/fR argument macros so they can't be used
6865        by mistake in the instruction body coming next. */
6866 #   undef JITTER_SLOW_REGISTER_OFFSET0
6867 #   undef JITTER_ARG0
6868 #   undef JITTER_ARGN0
6869 #   undef JITTER_ARGU0
6870 #   undef JITTER_ARGP0
6871 #   undef JITTER_ARGF0
6872 
6873 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6874 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6875 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6876 
6877   }
6878  JITTER_INSTRUCTION_EPILOG_(bnzi/fR, bnzi__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6879 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6880 
6881   JITTER_INSTRUCTION_PROLOG_(bnziu/fR, bnziu__fR, hot)
6882   {
6883     /* This specialized instruction is not a replacement. */
6884 #   undef JITTER_BRANCH_FAST
6885 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6886 #   undef JITTER_BRANCH_FAST_IF_ZERO
6887 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6888 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6889 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6890 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6891 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6892 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6893 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6894 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6895 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6896 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6897 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6898 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6899 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6900 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6901 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6902 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6903 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6904 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6905 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6906 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6907 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6908 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6909 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6910 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6911 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6912 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6913 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6914 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6915 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6916 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6917 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6918 #   undef JITTER_BRANCH_FAST_IF_AND
6919 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6920 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6921 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6922 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6923 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6924 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6925 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6926 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6927 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6928 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6929 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6930 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6931 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6932 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6933 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6934 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6935 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6936 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6937 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6938 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6939 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6940 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6941 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6942 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6943 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6944 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6945 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6946 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6947 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6948 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       34
6949 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnziu/fR
6950 
6951 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnziu__fR
6952 
6953   /* The residual arity varies depending on whether we have fast labels. */
6954 #ifdef JITTER_HAVE_PATCH_IN
6955   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6956 #else
6957   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
6958 #endif // #ifdef JITTER_HAVE_PATCH_IN
6959 
6960   /* Define argument-access macros for bnziu/fR . */
6961 #ifdef JITTER_HAVE_PATCH_IN
6962   /* Define argument-access macros assuming that fast branches are enabled. */
6963     /* The 0th argument is a "residual" fast label.  Define its
6964        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
6965        so that at replication time we know what instruction address to patch in. */
6966 #   define JITTER_ARGF0 0
6967     /* JITTER_ARG0 is intentionally not defined for a fast label. */
6968 
6969 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6970 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6971 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6972 
6973 #else
6974   /* Define argument-access macros assuming that fast branches are disabled. */
6975 #if defined(JITTER_DISPATCH_NO_THREADING)
6976 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
6977     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
6978 #elif defined (JITTER_REPLICATE)
6979 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
6980 #else
6981 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
6982 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6983 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6984 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6985 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6986 #   define JITTER_ARGF0 JITTER_ARGP0
6987 
6988 # endif // #ifdef JITTER_HAVE_PATCH_IN
6989 
6990 #if defined (JITTER_PROFILE_SAMPLE)
6991   JITTER_PROFILE_SAMPLE_UPDATE
6992      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6993       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6994   /* Force the compiler not move sample-profiling instrumentation
6995      beyond this point; this way the actual user code is timed.
6996      This is still not perfect, as residuals are materialised before
6997      we arrive here, but should be adequate at least for slow VM
6998      instructions. */
6999   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7000 #endif
7001 #if defined (JITTER_PROFILE_COUNT)
7002   /* Notice that, differently from the code above, this
7003      instrumentation code *can* be reordered freely: as long as a
7004      VM instruction is counted, the count increment can be placed
7005      anyehere.  Let GCC move this code and possibly achieve better
7006      throughput by exploiting instruction-level parallelism and
7007      therefore approximate more closely a non-profiled build. */
7008   JITTER_PROFILE_COUNT_UPDATE
7009      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7010       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7011 #endif
7012 
7013 /* User-specified code, instruction-beginning-c part: beginning. */
7014 
7015 /* User-specified code, instruction-beginning-c part: end */
7016 
7017 
7018     /* User code for bnziu/fR . */
7019 #line 3700 "../../libpoke/pvm.jitter"
7020 
7021     pvm_val tmp = JITTER_TOP_STACK ();
7022     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_UINT (tmp), JITTER_ARGF0);
7023 
7024     /* End of the user code for bnziu/fR . */
7025 
7026 /* User-specified code, instruction-end-c part: beginning. */
7027 
7028 /* User-specified code, instruction-end-c part: end */
7029 
7030     /* Undefine the bnziu/fR argument macros so they can't be used
7031        by mistake in the instruction body coming next. */
7032 #   undef JITTER_SLOW_REGISTER_OFFSET0
7033 #   undef JITTER_ARG0
7034 #   undef JITTER_ARGN0
7035 #   undef JITTER_ARGU0
7036 #   undef JITTER_ARGP0
7037 #   undef JITTER_ARGF0
7038 
7039 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7040 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7041 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7042 
7043   }
7044  JITTER_INSTRUCTION_EPILOG_(bnziu/fR, bnziu__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7045 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7046 
7047   JITTER_INSTRUCTION_PROLOG_(bnzl/fR, bnzl__fR, hot)
7048   {
7049     /* This specialized instruction is not a replacement. */
7050 #   undef JITTER_BRANCH_FAST
7051 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7052 #   undef JITTER_BRANCH_FAST_IF_ZERO
7053 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7054 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7055 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7056 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7057 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7058 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7059 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7060 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7061 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7062 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7063 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7064 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7065 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7066 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7067 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7068 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7069 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7070 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7071 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7072 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7073 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7074 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7075 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7076 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7077 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7078 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7079 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7080 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7081 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7082 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7083 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7084 #   undef JITTER_BRANCH_FAST_IF_AND
7085 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7086 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7087 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7088 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7089 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7090 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7091 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7092 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7093 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7094 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7095 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7096 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7097 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7098 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7099 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7100 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7101 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7102 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7103 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7104 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7105 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7106 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7107 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7108 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7109 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7110 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7111 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7112 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7113 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7114 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       35
7115 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnzl/fR
7116 
7117 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnzl__fR
7118 
7119   /* The residual arity varies depending on whether we have fast labels. */
7120 #ifdef JITTER_HAVE_PATCH_IN
7121   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
7122 #else
7123   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
7124 #endif // #ifdef JITTER_HAVE_PATCH_IN
7125 
7126   /* Define argument-access macros for bnzl/fR . */
7127 #ifdef JITTER_HAVE_PATCH_IN
7128   /* Define argument-access macros assuming that fast branches are enabled. */
7129     /* The 0th argument is a "residual" fast label.  Define its
7130        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
7131        so that at replication time we know what instruction address to patch in. */
7132 #   define JITTER_ARGF0 0
7133     /* JITTER_ARG0 is intentionally not defined for a fast label. */
7134 
7135 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7136 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7137 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7138 
7139 #else
7140   /* Define argument-access macros assuming that fast branches are disabled. */
7141 #if defined(JITTER_DISPATCH_NO_THREADING)
7142 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
7143     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
7144 #elif defined (JITTER_REPLICATE)
7145 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
7146 #else
7147 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
7148 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
7149 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7150 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7151 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7152 #   define JITTER_ARGF0 JITTER_ARGP0
7153 
7154 # endif // #ifdef JITTER_HAVE_PATCH_IN
7155 
7156 #if defined (JITTER_PROFILE_SAMPLE)
7157   JITTER_PROFILE_SAMPLE_UPDATE
7158      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7159       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7160   /* Force the compiler not move sample-profiling instrumentation
7161      beyond this point; this way the actual user code is timed.
7162      This is still not perfect, as residuals are materialised before
7163      we arrive here, but should be adequate at least for slow VM
7164      instructions. */
7165   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7166 #endif
7167 #if defined (JITTER_PROFILE_COUNT)
7168   /* Notice that, differently from the code above, this
7169      instrumentation code *can* be reordered freely: as long as a
7170      VM instruction is counted, the count increment can be placed
7171      anyehere.  Let GCC move this code and possibly achieve better
7172      throughput by exploiting instruction-level parallelism and
7173      therefore approximate more closely a non-profiled build. */
7174   JITTER_PROFILE_COUNT_UPDATE
7175      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7176       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7177 #endif
7178 
7179 /* User-specified code, instruction-beginning-c part: beginning. */
7180 
7181 /* User-specified code, instruction-beginning-c part: end */
7182 
7183 
7184     /* User code for bnzl/fR . */
7185 #line 3714 "../../libpoke/pvm.jitter"
7186 
7187     pvm_val tmp = JITTER_TOP_STACK ();
7188     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_LONG (tmp), JITTER_ARGF0);
7189 
7190     /* End of the user code for bnzl/fR . */
7191 
7192 /* User-specified code, instruction-end-c part: beginning. */
7193 
7194 /* User-specified code, instruction-end-c part: end */
7195 
7196     /* Undefine the bnzl/fR argument macros so they can't be used
7197        by mistake in the instruction body coming next. */
7198 #   undef JITTER_SLOW_REGISTER_OFFSET0
7199 #   undef JITTER_ARG0
7200 #   undef JITTER_ARGN0
7201 #   undef JITTER_ARGU0
7202 #   undef JITTER_ARGP0
7203 #   undef JITTER_ARGF0
7204 
7205 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7206 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7207 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7208 
7209   }
7210  JITTER_INSTRUCTION_EPILOG_(bnzl/fR, bnzl__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7211 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7212 
7213   JITTER_INSTRUCTION_PROLOG_(bnzlu/fR, bnzlu__fR, hot)
7214   {
7215     /* This specialized instruction is not a replacement. */
7216 #   undef JITTER_BRANCH_FAST
7217 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7218 #   undef JITTER_BRANCH_FAST_IF_ZERO
7219 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7220 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7221 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7222 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7223 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7224 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7225 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7226 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7227 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7228 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7229 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7230 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7231 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7232 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7233 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7234 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7235 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7236 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7237 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7238 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7239 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7240 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7241 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7242 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7243 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7244 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7245 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7246 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7247 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7248 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7249 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7250 #   undef JITTER_BRANCH_FAST_IF_AND
7251 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7252 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7253 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7254 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7255 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7256 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7257 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7258 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7259 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7260 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7261 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7262 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7263 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7264 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7265 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7266 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7267 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7268 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7269 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7270 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7271 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7272 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7273 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7274 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7275 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7276 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7277 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7278 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7279 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7280 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       36
7281 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bnzlu/fR
7282 
7283 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bnzlu__fR
7284 
7285   /* The residual arity varies depending on whether we have fast labels. */
7286 #ifdef JITTER_HAVE_PATCH_IN
7287   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
7288 #else
7289   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
7290 #endif // #ifdef JITTER_HAVE_PATCH_IN
7291 
7292   /* Define argument-access macros for bnzlu/fR . */
7293 #ifdef JITTER_HAVE_PATCH_IN
7294   /* Define argument-access macros assuming that fast branches are enabled. */
7295     /* The 0th argument is a "residual" fast label.  Define its
7296        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
7297        so that at replication time we know what instruction address to patch in. */
7298 #   define JITTER_ARGF0 0
7299     /* JITTER_ARG0 is intentionally not defined for a fast label. */
7300 
7301 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7302 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7303 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7304 
7305 #else
7306   /* Define argument-access macros assuming that fast branches are disabled. */
7307 #if defined(JITTER_DISPATCH_NO_THREADING)
7308 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
7309     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
7310 #elif defined (JITTER_REPLICATE)
7311 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
7312 #else
7313 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
7314 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
7315 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7316 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7317 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7318 #   define JITTER_ARGF0 JITTER_ARGP0
7319 
7320 # endif // #ifdef JITTER_HAVE_PATCH_IN
7321 
7322 #if defined (JITTER_PROFILE_SAMPLE)
7323   JITTER_PROFILE_SAMPLE_UPDATE
7324      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7325       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7326   /* Force the compiler not move sample-profiling instrumentation
7327      beyond this point; this way the actual user code is timed.
7328      This is still not perfect, as residuals are materialised before
7329      we arrive here, but should be adequate at least for slow VM
7330      instructions. */
7331   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7332 #endif
7333 #if defined (JITTER_PROFILE_COUNT)
7334   /* Notice that, differently from the code above, this
7335      instrumentation code *can* be reordered freely: as long as a
7336      VM instruction is counted, the count increment can be placed
7337      anyehere.  Let GCC move this code and possibly achieve better
7338      throughput by exploiting instruction-level parallelism and
7339      therefore approximate more closely a non-profiled build. */
7340   JITTER_PROFILE_COUNT_UPDATE
7341      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7342       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7343 #endif
7344 
7345 /* User-specified code, instruction-beginning-c part: beginning. */
7346 
7347 /* User-specified code, instruction-beginning-c part: end */
7348 
7349 
7350     /* User code for bnzlu/fR . */
7351 #line 3728 "../../libpoke/pvm.jitter"
7352 
7353     pvm_val tmp = JITTER_TOP_STACK ();
7354     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_ULONG (tmp), JITTER_ARGF0);
7355 
7356     /* End of the user code for bnzlu/fR . */
7357 
7358 /* User-specified code, instruction-end-c part: beginning. */
7359 
7360 /* User-specified code, instruction-end-c part: end */
7361 
7362     /* Undefine the bnzlu/fR argument macros so they can't be used
7363        by mistake in the instruction body coming next. */
7364 #   undef JITTER_SLOW_REGISTER_OFFSET0
7365 #   undef JITTER_ARG0
7366 #   undef JITTER_ARGN0
7367 #   undef JITTER_ARGU0
7368 #   undef JITTER_ARGP0
7369 #   undef JITTER_ARGF0
7370 
7371 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7372 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7373 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7374 
7375   }
7376  JITTER_INSTRUCTION_EPILOG_(bnzlu/fR, bnzlu__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7377 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7378 
7379   JITTER_INSTRUCTION_PROLOG_(bori, bori, hot)
7380   {
7381     /* This specialized instruction is not a replacement. */
7382 #   undef JITTER_BRANCH_FAST
7383 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7384 #   undef JITTER_BRANCH_FAST_IF_ZERO
7385 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7386 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7387 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7388 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7389 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7390 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7391 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7392 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7393 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7394 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7395 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7396 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7397 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7398 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7399 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7400 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7401 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7402 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7403 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7404 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7405 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7406 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7407 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7408 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7409 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7410 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7411 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7412 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7413 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7414 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7415 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7416 #   undef JITTER_BRANCH_FAST_IF_AND
7417 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7418 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7419 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7420 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7421 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7422 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7423 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7424 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7425 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7426 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7427 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7428 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7429 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7430 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7431 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7432 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7433 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7434 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7435 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7436 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7437 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7438 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7439 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7440 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7441 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7442 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7443 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7444 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7445 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7446 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       37
7447 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bori
7448 
7449 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bori
7450 
7451   /* The residual arity for this instruction does not depend on fast labels. */
7452   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
7453 
7454 
7455 #if defined (JITTER_PROFILE_SAMPLE)
7456   JITTER_PROFILE_SAMPLE_UPDATE
7457      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7458       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7459   /* Force the compiler not move sample-profiling instrumentation
7460      beyond this point; this way the actual user code is timed.
7461      This is still not perfect, as residuals are materialised before
7462      we arrive here, but should be adequate at least for slow VM
7463      instructions. */
7464   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7465 #endif
7466 #if defined (JITTER_PROFILE_COUNT)
7467   /* Notice that, differently from the code above, this
7468      instrumentation code *can* be reordered freely: as long as a
7469      VM instruction is counted, the count increment can be placed
7470      anyehere.  Let GCC move this code and possibly achieve better
7471      throughput by exploiting instruction-level parallelism and
7472      therefore approximate more closely a non-profiled build. */
7473   JITTER_PROFILE_COUNT_UPDATE
7474      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7475       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7476 #endif
7477 
7478 /* User-specified code, instruction-beginning-c part: beginning. */
7479 
7480 /* User-specified code, instruction-beginning-c part: end */
7481 
7482 
7483     /* User code for bori . */
7484 #line 3234 "../../libpoke/pvm.jitter"
7485 
7486     PVM_BINOP (INT, INT, INT, |);
7487 
7488     /* End of the user code for bori . */
7489 
7490 /* User-specified code, instruction-end-c part: beginning. */
7491 
7492 /* User-specified code, instruction-end-c part: end */
7493 
7494     /* Undefine the bori argument macros so they can't be used
7495        by mistake in the instruction body coming next. */
7496 
7497 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7498 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7499 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7500 
7501   }
7502  JITTER_INSTRUCTION_EPILOG_(bori, bori, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7503 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7504 
7505   JITTER_INSTRUCTION_PROLOG_(boriu, boriu, hot)
7506   {
7507     /* This specialized instruction is not a replacement. */
7508 #   undef JITTER_BRANCH_FAST
7509 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7510 #   undef JITTER_BRANCH_FAST_IF_ZERO
7511 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7512 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7513 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7514 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7515 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7516 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7517 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7518 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7519 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7520 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7521 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7522 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7523 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7524 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7525 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7526 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7527 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7528 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7529 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7530 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7531 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7532 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7533 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7534 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7535 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7536 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7537 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7538 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7539 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7540 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7541 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7542 #   undef JITTER_BRANCH_FAST_IF_AND
7543 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7544 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7545 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7546 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7547 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7548 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7549 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7550 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7551 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7552 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7553 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7554 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7555 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7556 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7557 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7558 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7559 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7560 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7561 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7562 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7563 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7564 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7565 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7566 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7567 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7568 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7569 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7570 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7571 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7572 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       38
7573 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         boriu
7574 
7575 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME boriu
7576 
7577   /* The residual arity for this instruction does not depend on fast labels. */
7578   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
7579 
7580 
7581 #if defined (JITTER_PROFILE_SAMPLE)
7582   JITTER_PROFILE_SAMPLE_UPDATE
7583      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7584       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7585   /* Force the compiler not move sample-profiling instrumentation
7586      beyond this point; this way the actual user code is timed.
7587      This is still not perfect, as residuals are materialised before
7588      we arrive here, but should be adequate at least for slow VM
7589      instructions. */
7590   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7591 #endif
7592 #if defined (JITTER_PROFILE_COUNT)
7593   /* Notice that, differently from the code above, this
7594      instrumentation code *can* be reordered freely: as long as a
7595      VM instruction is counted, the count increment can be placed
7596      anyehere.  Let GCC move this code and possibly achieve better
7597      throughput by exploiting instruction-level parallelism and
7598      therefore approximate more closely a non-profiled build. */
7599   JITTER_PROFILE_COUNT_UPDATE
7600      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7601       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7602 #endif
7603 
7604 /* User-specified code, instruction-beginning-c part: beginning. */
7605 
7606 /* User-specified code, instruction-beginning-c part: end */
7607 
7608 
7609     /* User code for boriu . */
7610 #line 3247 "../../libpoke/pvm.jitter"
7611 
7612     PVM_BINOP (UINT, UINT, UINT, |);
7613 
7614     /* End of the user code for boriu . */
7615 
7616 /* User-specified code, instruction-end-c part: beginning. */
7617 
7618 /* User-specified code, instruction-end-c part: end */
7619 
7620     /* Undefine the boriu argument macros so they can't be used
7621        by mistake in the instruction body coming next. */
7622 
7623 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7624 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7625 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7626 
7627   }
7628  JITTER_INSTRUCTION_EPILOG_(boriu, boriu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7629 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7630 
7631   JITTER_INSTRUCTION_PROLOG_(borl, borl, hot)
7632   {
7633     /* This specialized instruction is not a replacement. */
7634 #   undef JITTER_BRANCH_FAST
7635 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7636 #   undef JITTER_BRANCH_FAST_IF_ZERO
7637 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7638 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7639 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7640 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7641 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7642 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7643 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7644 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7645 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7646 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7647 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7648 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7649 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7650 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7651 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7652 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7653 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7654 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7655 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7656 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7657 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7658 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7659 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7660 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7661 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7662 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7663 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7664 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7665 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7666 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7667 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7668 #   undef JITTER_BRANCH_FAST_IF_AND
7669 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7670 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7671 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7672 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7673 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7674 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7675 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7676 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7677 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7678 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7679 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7680 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7681 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7682 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7683 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7684 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7685 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7686 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7687 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7688 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7689 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7690 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7691 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7692 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7693 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7694 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7695 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7696 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7697 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7698 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       39
7699 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         borl
7700 
7701 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME borl
7702 
7703   /* The residual arity for this instruction does not depend on fast labels. */
7704   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
7705 
7706 
7707 #if defined (JITTER_PROFILE_SAMPLE)
7708   JITTER_PROFILE_SAMPLE_UPDATE
7709      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7710       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7711   /* Force the compiler not move sample-profiling instrumentation
7712      beyond this point; this way the actual user code is timed.
7713      This is still not perfect, as residuals are materialised before
7714      we arrive here, but should be adequate at least for slow VM
7715      instructions. */
7716   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7717 #endif
7718 #if defined (JITTER_PROFILE_COUNT)
7719   /* Notice that, differently from the code above, this
7720      instrumentation code *can* be reordered freely: as long as a
7721      VM instruction is counted, the count increment can be placed
7722      anyehere.  Let GCC move this code and possibly achieve better
7723      throughput by exploiting instruction-level parallelism and
7724      therefore approximate more closely a non-profiled build. */
7725   JITTER_PROFILE_COUNT_UPDATE
7726      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7727       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7728 #endif
7729 
7730 /* User-specified code, instruction-beginning-c part: beginning. */
7731 
7732 /* User-specified code, instruction-beginning-c part: end */
7733 
7734 
7735     /* User code for borl . */
7736 #line 3259 "../../libpoke/pvm.jitter"
7737 
7738     PVM_BINOP (LONG, LONG, LONG, |);
7739 
7740     /* End of the user code for borl . */
7741 
7742 /* User-specified code, instruction-end-c part: beginning. */
7743 
7744 /* User-specified code, instruction-end-c part: end */
7745 
7746     /* Undefine the borl argument macros so they can't be used
7747        by mistake in the instruction body coming next. */
7748 
7749 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7750 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7751 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7752 
7753   }
7754  JITTER_INSTRUCTION_EPILOG_(borl, borl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7755 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7756 
7757   JITTER_INSTRUCTION_PROLOG_(borlu, borlu, hot)
7758   {
7759     /* This specialized instruction is not a replacement. */
7760 #   undef JITTER_BRANCH_FAST
7761 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7762 #   undef JITTER_BRANCH_FAST_IF_ZERO
7763 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7764 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7765 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7766 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7767 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7768 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7769 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7770 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7771 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7772 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7773 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7774 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7775 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7776 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7777 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7778 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7779 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7780 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7781 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7782 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7783 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7784 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7785 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7786 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7787 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7788 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7789 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7790 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7791 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7792 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7793 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7794 #   undef JITTER_BRANCH_FAST_IF_AND
7795 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7796 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7797 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7798 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7799 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7800 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7801 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7802 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7803 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7804 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7805 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7806 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7807 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7808 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7809 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7810 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7811 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7812 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7813 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7814 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7815 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7816 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7817 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7818 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7819 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7820 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7821 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7822 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7823 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7824 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       40
7825 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         borlu
7826 
7827 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME borlu
7828 
7829   /* The residual arity for this instruction does not depend on fast labels. */
7830   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
7831 
7832 
7833 #if defined (JITTER_PROFILE_SAMPLE)
7834   JITTER_PROFILE_SAMPLE_UPDATE
7835      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7836       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7837   /* Force the compiler not move sample-profiling instrumentation
7838      beyond this point; this way the actual user code is timed.
7839      This is still not perfect, as residuals are materialised before
7840      we arrive here, but should be adequate at least for slow VM
7841      instructions. */
7842   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7843 #endif
7844 #if defined (JITTER_PROFILE_COUNT)
7845   /* Notice that, differently from the code above, this
7846      instrumentation code *can* be reordered freely: as long as a
7847      VM instruction is counted, the count increment can be placed
7848      anyehere.  Let GCC move this code and possibly achieve better
7849      throughput by exploiting instruction-level parallelism and
7850      therefore approximate more closely a non-profiled build. */
7851   JITTER_PROFILE_COUNT_UPDATE
7852      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7853       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7854 #endif
7855 
7856 /* User-specified code, instruction-beginning-c part: beginning. */
7857 
7858 /* User-specified code, instruction-beginning-c part: end */
7859 
7860 
7861     /* User code for borlu . */
7862 #line 3271 "../../libpoke/pvm.jitter"
7863 
7864     PVM_BINOP (ULONG, ULONG, ULONG, |);
7865 
7866     /* End of the user code for borlu . */
7867 
7868 /* User-specified code, instruction-end-c part: beginning. */
7869 
7870 /* User-specified code, instruction-end-c part: end */
7871 
7872     /* Undefine the borlu argument macros so they can't be used
7873        by mistake in the instruction body coming next. */
7874 
7875 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7876 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7877 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7878 
7879   }
7880  JITTER_INSTRUCTION_EPILOG_(borlu, borlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7881 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7882 
7883   JITTER_INSTRUCTION_PROLOG_(bsli, bsli, hot)
7884   {
7885     /* This specialized instruction is not a replacement. */
7886 #   undef JITTER_BRANCH_FAST
7887 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7888 #   undef JITTER_BRANCH_FAST_IF_ZERO
7889 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7890 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7891 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7892 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7893 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7894 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7895 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7896 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7897 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7898 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7899 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7900 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7901 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7902 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7903 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7904 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7905 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7906 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7907 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7908 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7909 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7910 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7911 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7912 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7913 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7914 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7915 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7916 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7917 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7918 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7919 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7920 #   undef JITTER_BRANCH_FAST_IF_AND
7921 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7922 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7923 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7924 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7925 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7926 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7927 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7928 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7929 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7930 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7931 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7932 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7933 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7934 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7935 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7936 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7937 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7938 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7939 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7940 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7941 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7942 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7943 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7944 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7945 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7946 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7947 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7948 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7949 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7950 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       41
7951 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsli
7952 
7953 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsli
7954 
7955   /* The residual arity for this instruction does not depend on fast labels. */
7956   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
7957 
7958 
7959 #if defined (JITTER_PROFILE_SAMPLE)
7960   JITTER_PROFILE_SAMPLE_UPDATE
7961      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7962       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7963   /* Force the compiler not move sample-profiling instrumentation
7964      beyond this point; this way the actual user code is timed.
7965      This is still not perfect, as residuals are materialised before
7966      we arrive here, but should be adequate at least for slow VM
7967      instructions. */
7968   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7969 #endif
7970 #if defined (JITTER_PROFILE_COUNT)
7971   /* Notice that, differently from the code above, this
7972      instrumentation code *can* be reordered freely: as long as a
7973      VM instruction is counted, the count increment can be placed
7974      anyehere.  Let GCC move this code and possibly achieve better
7975      throughput by exploiting instruction-level parallelism and
7976      therefore approximate more closely a non-profiled build. */
7977   JITTER_PROFILE_COUNT_UPDATE
7978      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7979       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7980 #endif
7981 
7982 /* User-specified code, instruction-beginning-c part: beginning. */
7983 
7984 /* User-specified code, instruction-beginning-c part: end */
7985 
7986 
7987     /* User code for bsli . */
7988 #line 3390 "../../libpoke/pvm.jitter"
7989 
7990     PVM_BINOP_SL (INT, UINT, INT, <<);
7991 
7992     /* End of the user code for bsli . */
7993 
7994 /* User-specified code, instruction-end-c part: beginning. */
7995 
7996 /* User-specified code, instruction-end-c part: end */
7997 
7998     /* Undefine the bsli argument macros so they can't be used
7999        by mistake in the instruction body coming next. */
8000 
8001 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8002 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8003 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8004 
8005   }
8006  JITTER_INSTRUCTION_EPILOG_(bsli, bsli, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8007 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8008 
8009   JITTER_INSTRUCTION_PROLOG_(bsliu, bsliu, hot)
8010   {
8011     /* This specialized instruction is not a replacement. */
8012 #   undef JITTER_BRANCH_FAST
8013 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8014 #   undef JITTER_BRANCH_FAST_IF_ZERO
8015 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8016 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8017 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8018 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8019 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8020 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8021 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8022 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8023 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8024 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8025 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8026 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8027 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8028 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8029 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8030 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8031 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8032 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8033 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8034 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8035 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8036 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8037 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8038 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8039 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8040 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8041 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8042 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8043 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8044 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8045 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8046 #   undef JITTER_BRANCH_FAST_IF_AND
8047 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8048 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8049 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8050 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8051 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8052 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8053 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8054 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8055 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8056 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8057 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8058 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8059 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8060 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8061 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8062 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8063 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8064 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8065 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8066 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8067 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8068 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8069 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8070 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8071 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8072 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8073 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8074 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8075 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8076 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       42
8077 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsliu
8078 
8079 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsliu
8080 
8081   /* The residual arity for this instruction does not depend on fast labels. */
8082   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8083 
8084 
8085 #if defined (JITTER_PROFILE_SAMPLE)
8086   JITTER_PROFILE_SAMPLE_UPDATE
8087      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8088       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8089   /* Force the compiler not move sample-profiling instrumentation
8090      beyond this point; this way the actual user code is timed.
8091      This is still not perfect, as residuals are materialised before
8092      we arrive here, but should be adequate at least for slow VM
8093      instructions. */
8094   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8095 #endif
8096 #if defined (JITTER_PROFILE_COUNT)
8097   /* Notice that, differently from the code above, this
8098      instrumentation code *can* be reordered freely: as long as a
8099      VM instruction is counted, the count increment can be placed
8100      anyehere.  Let GCC move this code and possibly achieve better
8101      throughput by exploiting instruction-level parallelism and
8102      therefore approximate more closely a non-profiled build. */
8103   JITTER_PROFILE_COUNT_UPDATE
8104      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8105       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8106 #endif
8107 
8108 /* User-specified code, instruction-beginning-c part: beginning. */
8109 
8110 /* User-specified code, instruction-beginning-c part: end */
8111 
8112 
8113     /* User code for bsliu . */
8114 #line 3408 "../../libpoke/pvm.jitter"
8115 
8116     PVM_BINOP_SL (UINT, UINT, UINT, <<);
8117 
8118     /* End of the user code for bsliu . */
8119 
8120 /* User-specified code, instruction-end-c part: beginning. */
8121 
8122 /* User-specified code, instruction-end-c part: end */
8123 
8124     /* Undefine the bsliu argument macros so they can't be used
8125        by mistake in the instruction body coming next. */
8126 
8127 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8128 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8129 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8130 
8131   }
8132  JITTER_INSTRUCTION_EPILOG_(bsliu, bsliu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8133 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8134 
8135   JITTER_INSTRUCTION_PROLOG_(bsll, bsll, hot)
8136   {
8137     /* This specialized instruction is not a replacement. */
8138 #   undef JITTER_BRANCH_FAST
8139 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8140 #   undef JITTER_BRANCH_FAST_IF_ZERO
8141 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8142 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8143 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8144 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8145 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8146 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8147 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8148 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8149 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8150 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8151 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8152 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8153 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8154 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8155 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8156 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8157 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8158 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8159 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8160 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8161 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8162 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8163 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8164 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8165 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8166 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8167 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8168 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8169 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8170 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8171 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8172 #   undef JITTER_BRANCH_FAST_IF_AND
8173 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8174 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8175 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8176 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8177 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8178 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8179 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8180 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8181 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8182 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8183 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8184 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8185 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8186 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8187 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8188 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8189 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8190 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8191 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8192 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8193 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8194 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8195 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8196 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8197 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8198 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8199 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8200 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8201 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8202 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       43
8203 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsll
8204 
8205 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsll
8206 
8207   /* The residual arity for this instruction does not depend on fast labels. */
8208   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8209 
8210 
8211 #if defined (JITTER_PROFILE_SAMPLE)
8212   JITTER_PROFILE_SAMPLE_UPDATE
8213      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8214       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8215   /* Force the compiler not move sample-profiling instrumentation
8216      beyond this point; this way the actual user code is timed.
8217      This is still not perfect, as residuals are materialised before
8218      we arrive here, but should be adequate at least for slow VM
8219      instructions. */
8220   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8221 #endif
8222 #if defined (JITTER_PROFILE_COUNT)
8223   /* Notice that, differently from the code above, this
8224      instrumentation code *can* be reordered freely: as long as a
8225      VM instruction is counted, the count increment can be placed
8226      anyehere.  Let GCC move this code and possibly achieve better
8227      throughput by exploiting instruction-level parallelism and
8228      therefore approximate more closely a non-profiled build. */
8229   JITTER_PROFILE_COUNT_UPDATE
8230      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8231       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8232 #endif
8233 
8234 /* User-specified code, instruction-beginning-c part: beginning. */
8235 
8236 /* User-specified code, instruction-beginning-c part: end */
8237 
8238 
8239     /* User code for bsll . */
8240 #line 3425 "../../libpoke/pvm.jitter"
8241 
8242     PVM_BINOP_SL (LONG, UINT, LONG, <<);
8243 
8244     /* End of the user code for bsll . */
8245 
8246 /* User-specified code, instruction-end-c part: beginning. */
8247 
8248 /* User-specified code, instruction-end-c part: end */
8249 
8250     /* Undefine the bsll argument macros so they can't be used
8251        by mistake in the instruction body coming next. */
8252 
8253 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8254 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8255 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8256 
8257   }
8258  JITTER_INSTRUCTION_EPILOG_(bsll, bsll, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8259 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8260 
8261   JITTER_INSTRUCTION_PROLOG_(bsllu, bsllu, hot)
8262   {
8263     /* This specialized instruction is not a replacement. */
8264 #   undef JITTER_BRANCH_FAST
8265 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8266 #   undef JITTER_BRANCH_FAST_IF_ZERO
8267 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8268 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8269 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8270 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8271 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8272 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8273 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8274 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8275 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8276 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8277 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8278 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8279 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8280 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8281 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8282 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8283 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8284 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8285 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8286 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8287 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8288 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8289 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8290 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8291 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8292 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8293 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8294 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8295 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8296 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8297 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8298 #   undef JITTER_BRANCH_FAST_IF_AND
8299 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8300 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8301 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8302 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8303 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8304 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8305 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8306 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8307 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8308 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8309 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8310 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8311 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8312 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8313 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8314 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8315 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8316 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8317 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8318 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8319 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8320 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8321 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8322 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8323 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8324 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8325 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8326 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8327 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8328 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       44
8329 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsllu
8330 
8331 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsllu
8332 
8333   /* The residual arity for this instruction does not depend on fast labels. */
8334   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8335 
8336 
8337 #if defined (JITTER_PROFILE_SAMPLE)
8338   JITTER_PROFILE_SAMPLE_UPDATE
8339      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8340       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8341   /* Force the compiler not move sample-profiling instrumentation
8342      beyond this point; this way the actual user code is timed.
8343      This is still not perfect, as residuals are materialised before
8344      we arrive here, but should be adequate at least for slow VM
8345      instructions. */
8346   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8347 #endif
8348 #if defined (JITTER_PROFILE_COUNT)
8349   /* Notice that, differently from the code above, this
8350      instrumentation code *can* be reordered freely: as long as a
8351      VM instruction is counted, the count increment can be placed
8352      anyehere.  Let GCC move this code and possibly achieve better
8353      throughput by exploiting instruction-level parallelism and
8354      therefore approximate more closely a non-profiled build. */
8355   JITTER_PROFILE_COUNT_UPDATE
8356      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8357       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8358 #endif
8359 
8360 /* User-specified code, instruction-beginning-c part: beginning. */
8361 
8362 /* User-specified code, instruction-beginning-c part: end */
8363 
8364 
8365     /* User code for bsllu . */
8366 #line 3443 "../../libpoke/pvm.jitter"
8367 
8368     PVM_BINOP_SL (ULONG, UINT, ULONG, <<);
8369 
8370     /* End of the user code for bsllu . */
8371 
8372 /* User-specified code, instruction-end-c part: beginning. */
8373 
8374 /* User-specified code, instruction-end-c part: end */
8375 
8376     /* Undefine the bsllu argument macros so they can't be used
8377        by mistake in the instruction body coming next. */
8378 
8379 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8380 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8381 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8382 
8383   }
8384  JITTER_INSTRUCTION_EPILOG_(bsllu, bsllu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8385 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8386 
8387   JITTER_INSTRUCTION_PROLOG_(bsri, bsri, hot)
8388   {
8389     /* This specialized instruction is not a replacement. */
8390 #   undef JITTER_BRANCH_FAST
8391 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8392 #   undef JITTER_BRANCH_FAST_IF_ZERO
8393 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8394 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8395 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8396 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8397 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8398 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8399 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8400 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8401 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8402 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8403 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8404 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8405 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8406 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8407 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8408 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8409 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8410 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8411 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8412 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8413 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8414 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8415 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8416 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8417 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8418 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8419 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8420 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8421 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8422 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8423 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8424 #   undef JITTER_BRANCH_FAST_IF_AND
8425 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8426 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8427 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8428 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8429 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8430 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8431 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8432 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8433 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8434 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8435 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8436 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8437 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8438 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8439 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8440 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8441 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8442 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8443 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8444 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8445 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8446 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8447 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8448 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8449 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8450 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8451 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8452 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8453 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8454 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       45
8455 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsri
8456 
8457 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsri
8458 
8459   /* The residual arity for this instruction does not depend on fast labels. */
8460   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8461 
8462 
8463 #if defined (JITTER_PROFILE_SAMPLE)
8464   JITTER_PROFILE_SAMPLE_UPDATE
8465      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8466       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8467   /* Force the compiler not move sample-profiling instrumentation
8468      beyond this point; this way the actual user code is timed.
8469      This is still not perfect, as residuals are materialised before
8470      we arrive here, but should be adequate at least for slow VM
8471      instructions. */
8472   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8473 #endif
8474 #if defined (JITTER_PROFILE_COUNT)
8475   /* Notice that, differently from the code above, this
8476      instrumentation code *can* be reordered freely: as long as a
8477      VM instruction is counted, the count increment can be placed
8478      anyehere.  Let GCC move this code and possibly achieve better
8479      throughput by exploiting instruction-level parallelism and
8480      therefore approximate more closely a non-profiled build. */
8481   JITTER_PROFILE_COUNT_UPDATE
8482      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8483       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8484 #endif
8485 
8486 /* User-specified code, instruction-beginning-c part: beginning. */
8487 
8488 /* User-specified code, instruction-beginning-c part: end */
8489 
8490 
8491     /* User code for bsri . */
8492 #line 3456 "../../libpoke/pvm.jitter"
8493 
8494     PVM_BINOP (INT, UINT, INT, >>);
8495 
8496     /* End of the user code for bsri . */
8497 
8498 /* User-specified code, instruction-end-c part: beginning. */
8499 
8500 /* User-specified code, instruction-end-c part: end */
8501 
8502     /* Undefine the bsri argument macros so they can't be used
8503        by mistake in the instruction body coming next. */
8504 
8505 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8506 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8507 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8508 
8509   }
8510  JITTER_INSTRUCTION_EPILOG_(bsri, bsri, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8511 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8512 
8513   JITTER_INSTRUCTION_PROLOG_(bsriu, bsriu, hot)
8514   {
8515     /* This specialized instruction is not a replacement. */
8516 #   undef JITTER_BRANCH_FAST
8517 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8518 #   undef JITTER_BRANCH_FAST_IF_ZERO
8519 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8520 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8521 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8522 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8523 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8524 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8525 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8526 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8527 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8528 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8529 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8530 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8531 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8532 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8533 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8534 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8535 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8536 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8537 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8538 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8539 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8540 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8541 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8542 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8543 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8544 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8545 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8546 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8547 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8548 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8549 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8550 #   undef JITTER_BRANCH_FAST_IF_AND
8551 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8552 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8553 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8554 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8555 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8556 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8557 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8558 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8559 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8560 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8561 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8562 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8563 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8564 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8565 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8566 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8567 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8568 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8569 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8570 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8571 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8572 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8573 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8574 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8575 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8576 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8577 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8578 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8579 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8580 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       46
8581 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsriu
8582 
8583 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsriu
8584 
8585   /* The residual arity for this instruction does not depend on fast labels. */
8586   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8587 
8588 
8589 #if defined (JITTER_PROFILE_SAMPLE)
8590   JITTER_PROFILE_SAMPLE_UPDATE
8591      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8592       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8593   /* Force the compiler not move sample-profiling instrumentation
8594      beyond this point; this way the actual user code is timed.
8595      This is still not perfect, as residuals are materialised before
8596      we arrive here, but should be adequate at least for slow VM
8597      instructions. */
8598   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8599 #endif
8600 #if defined (JITTER_PROFILE_COUNT)
8601   /* Notice that, differently from the code above, this
8602      instrumentation code *can* be reordered freely: as long as a
8603      VM instruction is counted, the count increment can be placed
8604      anyehere.  Let GCC move this code and possibly achieve better
8605      throughput by exploiting instruction-level parallelism and
8606      therefore approximate more closely a non-profiled build. */
8607   JITTER_PROFILE_COUNT_UPDATE
8608      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8609       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8610 #endif
8611 
8612 /* User-specified code, instruction-beginning-c part: beginning. */
8613 
8614 /* User-specified code, instruction-beginning-c part: end */
8615 
8616 
8617     /* User code for bsriu . */
8618 #line 3469 "../../libpoke/pvm.jitter"
8619 
8620     PVM_BINOP (UINT, UINT, UINT, >>);
8621 
8622     /* End of the user code for bsriu . */
8623 
8624 /* User-specified code, instruction-end-c part: beginning. */
8625 
8626 /* User-specified code, instruction-end-c part: end */
8627 
8628     /* Undefine the bsriu argument macros so they can't be used
8629        by mistake in the instruction body coming next. */
8630 
8631 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8632 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8633 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8634 
8635   }
8636  JITTER_INSTRUCTION_EPILOG_(bsriu, bsriu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8637 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8638 
8639   JITTER_INSTRUCTION_PROLOG_(bsrl, bsrl, hot)
8640   {
8641     /* This specialized instruction is not a replacement. */
8642 #   undef JITTER_BRANCH_FAST
8643 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8644 #   undef JITTER_BRANCH_FAST_IF_ZERO
8645 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8646 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8647 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8648 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8649 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8650 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8651 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8652 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8653 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8654 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8655 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8656 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8657 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8658 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8659 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8660 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8661 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8662 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8663 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8664 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8665 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8666 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8667 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8668 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8669 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8670 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8671 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8672 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8673 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8674 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8675 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8676 #   undef JITTER_BRANCH_FAST_IF_AND
8677 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8678 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8679 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8680 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8681 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8682 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8683 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8684 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8685 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8686 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8687 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8688 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8689 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8690 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8691 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8692 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8693 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8694 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8695 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8696 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8697 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8698 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8699 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8700 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8701 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8702 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8703 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8704 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8705 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8706 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       47
8707 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsrl
8708 
8709 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsrl
8710 
8711   /* The residual arity for this instruction does not depend on fast labels. */
8712   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8713 
8714 
8715 #if defined (JITTER_PROFILE_SAMPLE)
8716   JITTER_PROFILE_SAMPLE_UPDATE
8717      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8718       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8719   /* Force the compiler not move sample-profiling instrumentation
8720      beyond this point; this way the actual user code is timed.
8721      This is still not perfect, as residuals are materialised before
8722      we arrive here, but should be adequate at least for slow VM
8723      instructions. */
8724   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8725 #endif
8726 #if defined (JITTER_PROFILE_COUNT)
8727   /* Notice that, differently from the code above, this
8728      instrumentation code *can* be reordered freely: as long as a
8729      VM instruction is counted, the count increment can be placed
8730      anyehere.  Let GCC move this code and possibly achieve better
8731      throughput by exploiting instruction-level parallelism and
8732      therefore approximate more closely a non-profiled build. */
8733   JITTER_PROFILE_COUNT_UPDATE
8734      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8735       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8736 #endif
8737 
8738 /* User-specified code, instruction-beginning-c part: beginning. */
8739 
8740 /* User-specified code, instruction-beginning-c part: end */
8741 
8742 
8743     /* User code for bsrl . */
8744 #line 3482 "../../libpoke/pvm.jitter"
8745 
8746     PVM_BINOP (LONG, UINT, LONG, >>);
8747 
8748     /* End of the user code for bsrl . */
8749 
8750 /* User-specified code, instruction-end-c part: beginning. */
8751 
8752 /* User-specified code, instruction-end-c part: end */
8753 
8754     /* Undefine the bsrl argument macros so they can't be used
8755        by mistake in the instruction body coming next. */
8756 
8757 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8758 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8759 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8760 
8761   }
8762  JITTER_INSTRUCTION_EPILOG_(bsrl, bsrl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8763 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8764 
8765   JITTER_INSTRUCTION_PROLOG_(bsrlu, bsrlu, hot)
8766   {
8767     /* This specialized instruction is not a replacement. */
8768 #   undef JITTER_BRANCH_FAST
8769 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8770 #   undef JITTER_BRANCH_FAST_IF_ZERO
8771 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8772 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8773 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8774 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8775 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8776 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8777 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8778 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8779 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8780 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8781 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8782 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8783 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8784 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8785 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8786 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8787 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8788 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8789 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8790 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8791 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8792 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8793 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8794 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8795 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8796 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8797 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8798 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8799 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8800 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8801 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8802 #   undef JITTER_BRANCH_FAST_IF_AND
8803 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8804 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8805 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8806 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8807 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8808 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8809 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8810 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8811 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8812 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8813 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8814 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8815 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8816 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8817 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8818 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8819 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8820 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8821 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8822 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8823 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8824 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8825 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8826 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8827 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8828 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8829 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8830 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8831 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8832 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       48
8833 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bsrlu
8834 
8835 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bsrlu
8836 
8837   /* The residual arity for this instruction does not depend on fast labels. */
8838   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8839 
8840 
8841 #if defined (JITTER_PROFILE_SAMPLE)
8842   JITTER_PROFILE_SAMPLE_UPDATE
8843      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8844       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8845   /* Force the compiler not move sample-profiling instrumentation
8846      beyond this point; this way the actual user code is timed.
8847      This is still not perfect, as residuals are materialised before
8848      we arrive here, but should be adequate at least for slow VM
8849      instructions. */
8850   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8851 #endif
8852 #if defined (JITTER_PROFILE_COUNT)
8853   /* Notice that, differently from the code above, this
8854      instrumentation code *can* be reordered freely: as long as a
8855      VM instruction is counted, the count increment can be placed
8856      anyehere.  Let GCC move this code and possibly achieve better
8857      throughput by exploiting instruction-level parallelism and
8858      therefore approximate more closely a non-profiled build. */
8859   JITTER_PROFILE_COUNT_UPDATE
8860      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8861       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8862 #endif
8863 
8864 /* User-specified code, instruction-beginning-c part: beginning. */
8865 
8866 /* User-specified code, instruction-beginning-c part: end */
8867 
8868 
8869     /* User code for bsrlu . */
8870 #line 3495 "../../libpoke/pvm.jitter"
8871 
8872     PVM_BINOP (ULONG, UINT, ULONG, >>);
8873 
8874     /* End of the user code for bsrlu . */
8875 
8876 /* User-specified code, instruction-end-c part: beginning. */
8877 
8878 /* User-specified code, instruction-end-c part: end */
8879 
8880     /* Undefine the bsrlu argument macros so they can't be used
8881        by mistake in the instruction body coming next. */
8882 
8883 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8884 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8885 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8886 
8887   }
8888  JITTER_INSTRUCTION_EPILOG_(bsrlu, bsrlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8889 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8890 
8891   JITTER_INSTRUCTION_PROLOG_(bxori, bxori, hot)
8892   {
8893     /* This specialized instruction is not a replacement. */
8894 #   undef JITTER_BRANCH_FAST
8895 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8896 #   undef JITTER_BRANCH_FAST_IF_ZERO
8897 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8898 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8899 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8900 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8901 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8902 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8903 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8904 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8905 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8906 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8907 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8908 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8909 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8910 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8911 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8912 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8913 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8914 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8915 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8916 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8917 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8918 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8919 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8920 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8921 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8922 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8923 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8924 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8925 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8926 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8927 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8928 #   undef JITTER_BRANCH_FAST_IF_AND
8929 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8930 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8931 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8932 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8933 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8934 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8935 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8936 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8937 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8938 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8939 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8940 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8941 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8942 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8943 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8944 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8945 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8946 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8947 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8948 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8949 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8950 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8951 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8952 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8953 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8954 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8955 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8956 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8957 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8958 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       49
8959 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bxori
8960 
8961 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bxori
8962 
8963   /* The residual arity for this instruction does not depend on fast labels. */
8964   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
8965 
8966 
8967 #if defined (JITTER_PROFILE_SAMPLE)
8968   JITTER_PROFILE_SAMPLE_UPDATE
8969      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8970       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8971   /* Force the compiler not move sample-profiling instrumentation
8972      beyond this point; this way the actual user code is timed.
8973      This is still not perfect, as residuals are materialised before
8974      we arrive here, but should be adequate at least for slow VM
8975      instructions. */
8976   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8977 #endif
8978 #if defined (JITTER_PROFILE_COUNT)
8979   /* Notice that, differently from the code above, this
8980      instrumentation code *can* be reordered freely: as long as a
8981      VM instruction is counted, the count increment can be placed
8982      anyehere.  Let GCC move this code and possibly achieve better
8983      throughput by exploiting instruction-level parallelism and
8984      therefore approximate more closely a non-profiled build. */
8985   JITTER_PROFILE_COUNT_UPDATE
8986      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8987       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8988 #endif
8989 
8990 /* User-specified code, instruction-beginning-c part: beginning. */
8991 
8992 /* User-specified code, instruction-beginning-c part: end */
8993 
8994 
8995     /* User code for bxori . */
8996 #line 3183 "../../libpoke/pvm.jitter"
8997 
8998     PVM_BINOP (INT, INT, INT, ^);
8999 
9000     /* End of the user code for bxori . */
9001 
9002 /* User-specified code, instruction-end-c part: beginning. */
9003 
9004 /* User-specified code, instruction-end-c part: end */
9005 
9006     /* Undefine the bxori argument macros so they can't be used
9007        by mistake in the instruction body coming next. */
9008 
9009 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9010 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9011 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9012 
9013   }
9014  JITTER_INSTRUCTION_EPILOG_(bxori, bxori, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9015 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9016 
9017   JITTER_INSTRUCTION_PROLOG_(bxoriu, bxoriu, hot)
9018   {
9019     /* This specialized instruction is not a replacement. */
9020 #   undef JITTER_BRANCH_FAST
9021 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9022 #   undef JITTER_BRANCH_FAST_IF_ZERO
9023 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9024 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9025 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9026 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9027 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9028 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9029 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9030 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9031 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9032 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9033 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9034 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9035 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9036 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9037 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9038 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9039 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9040 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9041 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9042 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9043 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9044 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9045 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9046 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9047 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9048 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9049 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9050 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9051 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9052 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9053 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9054 #   undef JITTER_BRANCH_FAST_IF_AND
9055 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9056 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9057 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9058 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9059 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9060 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9061 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9062 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9063 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9064 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9065 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9066 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9067 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9068 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9069 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9070 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9071 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9072 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9073 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9074 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9075 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9076 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9077 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9078 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9079 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9080 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9081 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9082 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9083 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9084 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       50
9085 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bxoriu
9086 
9087 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bxoriu
9088 
9089   /* The residual arity for this instruction does not depend on fast labels. */
9090   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
9091 
9092 
9093 #if defined (JITTER_PROFILE_SAMPLE)
9094   JITTER_PROFILE_SAMPLE_UPDATE
9095      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9096       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9097   /* Force the compiler not move sample-profiling instrumentation
9098      beyond this point; this way the actual user code is timed.
9099      This is still not perfect, as residuals are materialised before
9100      we arrive here, but should be adequate at least for slow VM
9101      instructions. */
9102   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9103 #endif
9104 #if defined (JITTER_PROFILE_COUNT)
9105   /* Notice that, differently from the code above, this
9106      instrumentation code *can* be reordered freely: as long as a
9107      VM instruction is counted, the count increment can be placed
9108      anyehere.  Let GCC move this code and possibly achieve better
9109      throughput by exploiting instruction-level parallelism and
9110      therefore approximate more closely a non-profiled build. */
9111   JITTER_PROFILE_COUNT_UPDATE
9112      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9113       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9114 #endif
9115 
9116 /* User-specified code, instruction-beginning-c part: beginning. */
9117 
9118 /* User-specified code, instruction-beginning-c part: end */
9119 
9120 
9121     /* User code for bxoriu . */
9122 #line 3196 "../../libpoke/pvm.jitter"
9123 
9124     PVM_BINOP (UINT, UINT, UINT, ^);
9125 
9126     /* End of the user code for bxoriu . */
9127 
9128 /* User-specified code, instruction-end-c part: beginning. */
9129 
9130 /* User-specified code, instruction-end-c part: end */
9131 
9132     /* Undefine the bxoriu argument macros so they can't be used
9133        by mistake in the instruction body coming next. */
9134 
9135 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9136 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9137 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9138 
9139   }
9140  JITTER_INSTRUCTION_EPILOG_(bxoriu, bxoriu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9141 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9142 
9143   JITTER_INSTRUCTION_PROLOG_(bxorl, bxorl, hot)
9144   {
9145     /* This specialized instruction is not a replacement. */
9146 #   undef JITTER_BRANCH_FAST
9147 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9148 #   undef JITTER_BRANCH_FAST_IF_ZERO
9149 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9150 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9151 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9152 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9153 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9154 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9155 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9156 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9157 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9158 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9159 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9160 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9161 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9162 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9163 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9164 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9165 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9166 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9167 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9168 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9169 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9170 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9171 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9172 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9173 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9174 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9175 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9176 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9177 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9178 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9179 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9180 #   undef JITTER_BRANCH_FAST_IF_AND
9181 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9182 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9183 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9184 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9185 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9186 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9187 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9188 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9189 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9190 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9191 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9192 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9193 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9194 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9195 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9196 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9197 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9198 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9199 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9200 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9201 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9202 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9203 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9204 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9205 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9206 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9207 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9208 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9209 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9210 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       51
9211 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bxorl
9212 
9213 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bxorl
9214 
9215   /* The residual arity for this instruction does not depend on fast labels. */
9216   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
9217 
9218 
9219 #if defined (JITTER_PROFILE_SAMPLE)
9220   JITTER_PROFILE_SAMPLE_UPDATE
9221      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9222       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9223   /* Force the compiler not move sample-profiling instrumentation
9224      beyond this point; this way the actual user code is timed.
9225      This is still not perfect, as residuals are materialised before
9226      we arrive here, but should be adequate at least for slow VM
9227      instructions. */
9228   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9229 #endif
9230 #if defined (JITTER_PROFILE_COUNT)
9231   /* Notice that, differently from the code above, this
9232      instrumentation code *can* be reordered freely: as long as a
9233      VM instruction is counted, the count increment can be placed
9234      anyehere.  Let GCC move this code and possibly achieve better
9235      throughput by exploiting instruction-level parallelism and
9236      therefore approximate more closely a non-profiled build. */
9237   JITTER_PROFILE_COUNT_UPDATE
9238      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9239       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9240 #endif
9241 
9242 /* User-specified code, instruction-beginning-c part: beginning. */
9243 
9244 /* User-specified code, instruction-beginning-c part: end */
9245 
9246 
9247     /* User code for bxorl . */
9248 #line 3209 "../../libpoke/pvm.jitter"
9249 
9250     PVM_BINOP (LONG, LONG, LONG, ^);
9251 
9252     /* End of the user code for bxorl . */
9253 
9254 /* User-specified code, instruction-end-c part: beginning. */
9255 
9256 /* User-specified code, instruction-end-c part: end */
9257 
9258     /* Undefine the bxorl argument macros so they can't be used
9259        by mistake in the instruction body coming next. */
9260 
9261 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9262 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9263 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9264 
9265   }
9266  JITTER_INSTRUCTION_EPILOG_(bxorl, bxorl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9267 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9268 
9269   JITTER_INSTRUCTION_PROLOG_(bxorlu, bxorlu, hot)
9270   {
9271     /* This specialized instruction is not a replacement. */
9272 #   undef JITTER_BRANCH_FAST
9273 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9274 #   undef JITTER_BRANCH_FAST_IF_ZERO
9275 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9276 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9277 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9278 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9279 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9280 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9281 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9282 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9283 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9284 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9285 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9286 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9287 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9288 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9289 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9290 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9291 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9292 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9293 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9294 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9295 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9296 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9297 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9298 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9299 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9300 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9301 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9302 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9303 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9304 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9305 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9306 #   undef JITTER_BRANCH_FAST_IF_AND
9307 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9308 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9309 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9310 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9311 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9312 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9313 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9314 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9315 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9316 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9317 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9318 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9319 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9320 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9321 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9322 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9323 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9324 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9325 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9326 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9327 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9328 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9329 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9330 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9331 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9332 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9333 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9334 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9335 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9336 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       52
9337 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bxorlu
9338 
9339 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bxorlu
9340 
9341   /* The residual arity for this instruction does not depend on fast labels. */
9342   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
9343 
9344 
9345 #if defined (JITTER_PROFILE_SAMPLE)
9346   JITTER_PROFILE_SAMPLE_UPDATE
9347      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9348       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9349   /* Force the compiler not move sample-profiling instrumentation
9350      beyond this point; this way the actual user code is timed.
9351      This is still not perfect, as residuals are materialised before
9352      we arrive here, but should be adequate at least for slow VM
9353      instructions. */
9354   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9355 #endif
9356 #if defined (JITTER_PROFILE_COUNT)
9357   /* Notice that, differently from the code above, this
9358      instrumentation code *can* be reordered freely: as long as a
9359      VM instruction is counted, the count increment can be placed
9360      anyehere.  Let GCC move this code and possibly achieve better
9361      throughput by exploiting instruction-level parallelism and
9362      therefore approximate more closely a non-profiled build. */
9363   JITTER_PROFILE_COUNT_UPDATE
9364      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9365       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9366 #endif
9367 
9368 /* User-specified code, instruction-beginning-c part: beginning. */
9369 
9370 /* User-specified code, instruction-beginning-c part: end */
9371 
9372 
9373     /* User code for bxorlu . */
9374 #line 3222 "../../libpoke/pvm.jitter"
9375 
9376     PVM_BINOP (ULONG, ULONG, ULONG, ^);
9377 
9378     /* End of the user code for bxorlu . */
9379 
9380 /* User-specified code, instruction-end-c part: beginning. */
9381 
9382 /* User-specified code, instruction-end-c part: end */
9383 
9384     /* Undefine the bxorlu argument macros so they can't be used
9385        by mistake in the instruction body coming next. */
9386 
9387 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9388 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9389 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9390 
9391   }
9392  JITTER_INSTRUCTION_EPILOG_(bxorlu, bxorlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9393 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9394 
9395   JITTER_INSTRUCTION_PROLOG_(bzi/fR, bzi__fR, hot)
9396   {
9397     /* This specialized instruction is not a replacement. */
9398 #   undef JITTER_BRANCH_FAST
9399 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9400 #   undef JITTER_BRANCH_FAST_IF_ZERO
9401 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9402 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9403 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9404 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9405 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9406 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9407 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9408 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9409 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9410 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9411 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9412 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9413 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9414 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9415 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9416 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9417 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9418 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9419 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9420 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9421 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9422 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9423 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9424 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9425 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9426 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9427 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9428 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9429 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9430 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9431 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9432 #   undef JITTER_BRANCH_FAST_IF_AND
9433 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9434 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9435 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9436 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9437 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9438 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9439 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9440 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9441 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9442 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9443 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9444 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9445 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9446 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9447 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9448 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9449 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9450 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9451 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9452 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9453 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9454 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9455 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9456 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9457 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9458 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9459 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9460 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9461 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9462 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       53
9463 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bzi/fR
9464 
9465 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bzi__fR
9466 
9467   /* The residual arity varies depending on whether we have fast labels. */
9468 #ifdef JITTER_HAVE_PATCH_IN
9469   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
9470 #else
9471   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9472 #endif // #ifdef JITTER_HAVE_PATCH_IN
9473 
9474   /* Define argument-access macros for bzi/fR . */
9475 #ifdef JITTER_HAVE_PATCH_IN
9476   /* Define argument-access macros assuming that fast branches are enabled. */
9477     /* The 0th argument is a "residual" fast label.  Define its
9478        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
9479        so that at replication time we know what instruction address to patch in. */
9480 #   define JITTER_ARGF0 0
9481     /* JITTER_ARG0 is intentionally not defined for a fast label. */
9482 
9483 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9484 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9485 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9486 
9487 #else
9488   /* Define argument-access macros assuming that fast branches are disabled. */
9489 #if defined(JITTER_DISPATCH_NO_THREADING)
9490 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
9491     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9492 #elif defined (JITTER_REPLICATE)
9493 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
9494 #else
9495 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
9496 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9497 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9498 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9499 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9500 #   define JITTER_ARGF0 JITTER_ARGP0
9501 
9502 # endif // #ifdef JITTER_HAVE_PATCH_IN
9503 
9504 #if defined (JITTER_PROFILE_SAMPLE)
9505   JITTER_PROFILE_SAMPLE_UPDATE
9506      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9507       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9508   /* Force the compiler not move sample-profiling instrumentation
9509      beyond this point; this way the actual user code is timed.
9510      This is still not perfect, as residuals are materialised before
9511      we arrive here, but should be adequate at least for slow VM
9512      instructions. */
9513   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9514 #endif
9515 #if defined (JITTER_PROFILE_COUNT)
9516   /* Notice that, differently from the code above, this
9517      instrumentation code *can* be reordered freely: as long as a
9518      VM instruction is counted, the count increment can be placed
9519      anyehere.  Let GCC move this code and possibly achieve better
9520      throughput by exploiting instruction-level parallelism and
9521      therefore approximate more closely a non-profiled build. */
9522   JITTER_PROFILE_COUNT_UPDATE
9523      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9524       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9525 #endif
9526 
9527 /* User-specified code, instruction-beginning-c part: beginning. */
9528 
9529 /* User-specified code, instruction-beginning-c part: end */
9530 
9531 
9532     /* User code for bzi/fR . */
9533 #line 3630 "../../libpoke/pvm.jitter"
9534 
9535     pvm_val tmp = JITTER_TOP_STACK ();
9536     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_INT (tmp), JITTER_ARGF0);
9537 
9538     /* End of the user code for bzi/fR . */
9539 
9540 /* User-specified code, instruction-end-c part: beginning. */
9541 
9542 /* User-specified code, instruction-end-c part: end */
9543 
9544     /* Undefine the bzi/fR argument macros so they can't be used
9545        by mistake in the instruction body coming next. */
9546 #   undef JITTER_SLOW_REGISTER_OFFSET0
9547 #   undef JITTER_ARG0
9548 #   undef JITTER_ARGN0
9549 #   undef JITTER_ARGU0
9550 #   undef JITTER_ARGP0
9551 #   undef JITTER_ARGF0
9552 
9553 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9554 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9555 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9556 
9557   }
9558  JITTER_INSTRUCTION_EPILOG_(bzi/fR, bzi__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9559 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9560 
9561   JITTER_INSTRUCTION_PROLOG_(bziu/fR, bziu__fR, hot)
9562   {
9563     /* This specialized instruction is not a replacement. */
9564 #   undef JITTER_BRANCH_FAST
9565 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9566 #   undef JITTER_BRANCH_FAST_IF_ZERO
9567 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9568 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9569 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9570 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9571 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9572 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9573 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9574 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9575 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9576 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9577 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9578 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9579 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9580 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9581 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9582 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9583 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9584 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9585 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9586 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9587 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9588 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9589 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9590 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9591 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9592 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9593 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9594 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9595 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9596 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9597 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9598 #   undef JITTER_BRANCH_FAST_IF_AND
9599 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9600 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9601 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9602 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9603 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9604 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9605 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9606 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9607 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9608 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9609 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9610 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9611 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9612 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9613 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9614 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9615 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9616 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9617 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9618 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9619 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9620 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9621 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9622 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9623 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9624 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9625 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9626 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9627 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9628 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       54
9629 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bziu/fR
9630 
9631 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bziu__fR
9632 
9633   /* The residual arity varies depending on whether we have fast labels. */
9634 #ifdef JITTER_HAVE_PATCH_IN
9635   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
9636 #else
9637   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9638 #endif // #ifdef JITTER_HAVE_PATCH_IN
9639 
9640   /* Define argument-access macros for bziu/fR . */
9641 #ifdef JITTER_HAVE_PATCH_IN
9642   /* Define argument-access macros assuming that fast branches are enabled. */
9643     /* The 0th argument is a "residual" fast label.  Define its
9644        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
9645        so that at replication time we know what instruction address to patch in. */
9646 #   define JITTER_ARGF0 0
9647     /* JITTER_ARG0 is intentionally not defined for a fast label. */
9648 
9649 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9650 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9651 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9652 
9653 #else
9654   /* Define argument-access macros assuming that fast branches are disabled. */
9655 #if defined(JITTER_DISPATCH_NO_THREADING)
9656 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
9657     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9658 #elif defined (JITTER_REPLICATE)
9659 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
9660 #else
9661 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
9662 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9663 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9664 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9665 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9666 #   define JITTER_ARGF0 JITTER_ARGP0
9667 
9668 # endif // #ifdef JITTER_HAVE_PATCH_IN
9669 
9670 #if defined (JITTER_PROFILE_SAMPLE)
9671   JITTER_PROFILE_SAMPLE_UPDATE
9672      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9673       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9674   /* Force the compiler not move sample-profiling instrumentation
9675      beyond this point; this way the actual user code is timed.
9676      This is still not perfect, as residuals are materialised before
9677      we arrive here, but should be adequate at least for slow VM
9678      instructions. */
9679   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9680 #endif
9681 #if defined (JITTER_PROFILE_COUNT)
9682   /* Notice that, differently from the code above, this
9683      instrumentation code *can* be reordered freely: as long as a
9684      VM instruction is counted, the count increment can be placed
9685      anyehere.  Let GCC move this code and possibly achieve better
9686      throughput by exploiting instruction-level parallelism and
9687      therefore approximate more closely a non-profiled build. */
9688   JITTER_PROFILE_COUNT_UPDATE
9689      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9690       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9691 #endif
9692 
9693 /* User-specified code, instruction-beginning-c part: beginning. */
9694 
9695 /* User-specified code, instruction-beginning-c part: end */
9696 
9697 
9698     /* User code for bziu/fR . */
9699 #line 3644 "../../libpoke/pvm.jitter"
9700 
9701     pvm_val tmp = JITTER_TOP_STACK ();
9702     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_UINT (tmp), JITTER_ARGF0);
9703 
9704     /* End of the user code for bziu/fR . */
9705 
9706 /* User-specified code, instruction-end-c part: beginning. */
9707 
9708 /* User-specified code, instruction-end-c part: end */
9709 
9710     /* Undefine the bziu/fR argument macros so they can't be used
9711        by mistake in the instruction body coming next. */
9712 #   undef JITTER_SLOW_REGISTER_OFFSET0
9713 #   undef JITTER_ARG0
9714 #   undef JITTER_ARGN0
9715 #   undef JITTER_ARGU0
9716 #   undef JITTER_ARGP0
9717 #   undef JITTER_ARGF0
9718 
9719 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9720 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9721 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9722 
9723   }
9724  JITTER_INSTRUCTION_EPILOG_(bziu/fR, bziu__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9725 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9726 
9727   JITTER_INSTRUCTION_PROLOG_(bzl/fR, bzl__fR, hot)
9728   {
9729     /* This specialized instruction is not a replacement. */
9730 #   undef JITTER_BRANCH_FAST
9731 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9732 #   undef JITTER_BRANCH_FAST_IF_ZERO
9733 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9734 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9735 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9736 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9737 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9738 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9739 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9740 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9741 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9742 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9743 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9744 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9745 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9746 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9747 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9748 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9749 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9750 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9751 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9752 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9753 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9754 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9755 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9756 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9757 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9758 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9759 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9760 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9761 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9762 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9763 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9764 #   undef JITTER_BRANCH_FAST_IF_AND
9765 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9766 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9767 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9768 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9769 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9770 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9771 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9772 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9773 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9774 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9775 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9776 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9777 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9778 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9779 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9780 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9781 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9782 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9783 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9784 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9785 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9786 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9787 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9788 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9789 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9790 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9791 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9792 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9793 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9794 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       55
9795 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bzl/fR
9796 
9797 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bzl__fR
9798 
9799   /* The residual arity varies depending on whether we have fast labels. */
9800 #ifdef JITTER_HAVE_PATCH_IN
9801   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
9802 #else
9803   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9804 #endif // #ifdef JITTER_HAVE_PATCH_IN
9805 
9806   /* Define argument-access macros for bzl/fR . */
9807 #ifdef JITTER_HAVE_PATCH_IN
9808   /* Define argument-access macros assuming that fast branches are enabled. */
9809     /* The 0th argument is a "residual" fast label.  Define its
9810        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
9811        so that at replication time we know what instruction address to patch in. */
9812 #   define JITTER_ARGF0 0
9813     /* JITTER_ARG0 is intentionally not defined for a fast label. */
9814 
9815 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9816 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9817 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9818 
9819 #else
9820   /* Define argument-access macros assuming that fast branches are disabled. */
9821 #if defined(JITTER_DISPATCH_NO_THREADING)
9822 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
9823     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9824 #elif defined (JITTER_REPLICATE)
9825 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
9826 #else
9827 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
9828 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9829 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9830 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9831 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9832 #   define JITTER_ARGF0 JITTER_ARGP0
9833 
9834 # endif // #ifdef JITTER_HAVE_PATCH_IN
9835 
9836 #if defined (JITTER_PROFILE_SAMPLE)
9837   JITTER_PROFILE_SAMPLE_UPDATE
9838      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9839       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9840   /* Force the compiler not move sample-profiling instrumentation
9841      beyond this point; this way the actual user code is timed.
9842      This is still not perfect, as residuals are materialised before
9843      we arrive here, but should be adequate at least for slow VM
9844      instructions. */
9845   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9846 #endif
9847 #if defined (JITTER_PROFILE_COUNT)
9848   /* Notice that, differently from the code above, this
9849      instrumentation code *can* be reordered freely: as long as a
9850      VM instruction is counted, the count increment can be placed
9851      anyehere.  Let GCC move this code and possibly achieve better
9852      throughput by exploiting instruction-level parallelism and
9853      therefore approximate more closely a non-profiled build. */
9854   JITTER_PROFILE_COUNT_UPDATE
9855      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9856       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9857 #endif
9858 
9859 /* User-specified code, instruction-beginning-c part: beginning. */
9860 
9861 /* User-specified code, instruction-beginning-c part: end */
9862 
9863 
9864     /* User code for bzl/fR . */
9865 #line 3658 "../../libpoke/pvm.jitter"
9866 
9867     pvm_val tmp = JITTER_TOP_STACK ();
9868     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_LONG (tmp), JITTER_ARGF0);
9869 
9870     /* End of the user code for bzl/fR . */
9871 
9872 /* User-specified code, instruction-end-c part: beginning. */
9873 
9874 /* User-specified code, instruction-end-c part: end */
9875 
9876     /* Undefine the bzl/fR argument macros so they can't be used
9877        by mistake in the instruction body coming next. */
9878 #   undef JITTER_SLOW_REGISTER_OFFSET0
9879 #   undef JITTER_ARG0
9880 #   undef JITTER_ARGN0
9881 #   undef JITTER_ARGU0
9882 #   undef JITTER_ARGP0
9883 #   undef JITTER_ARGF0
9884 
9885 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9886 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9887 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9888 
9889   }
9890  JITTER_INSTRUCTION_EPILOG_(bzl/fR, bzl__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9891 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9892 
9893   JITTER_INSTRUCTION_PROLOG_(bzlu/fR, bzlu__fR, hot)
9894   {
9895     /* This specialized instruction is not a replacement. */
9896 #   undef JITTER_BRANCH_FAST
9897 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9898 #   undef JITTER_BRANCH_FAST_IF_ZERO
9899 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9900 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9901 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9902 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9903 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9904 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9905 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9906 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9907 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9908 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9909 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9910 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9911 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9912 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9913 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9914 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9915 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9916 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9917 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9918 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9919 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9920 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9921 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9922 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9923 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9924 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9925 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9926 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9927 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9928 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9929 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9930 #   undef JITTER_BRANCH_FAST_IF_AND
9931 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9932 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9933 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9934 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9935 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9936 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9937 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9938 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9939 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9940 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9941 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9942 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9943 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9944 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9945 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9946 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9947 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9948 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9949 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9950 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9951 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9952 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9953 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9954 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9955 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9956 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9957 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9958 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9959 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9960 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       56
9961 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         bzlu/fR
9962 
9963 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME bzlu__fR
9964 
9965   /* The residual arity varies depending on whether we have fast labels. */
9966 #ifdef JITTER_HAVE_PATCH_IN
9967   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
9968 #else
9969   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9970 #endif // #ifdef JITTER_HAVE_PATCH_IN
9971 
9972   /* Define argument-access macros for bzlu/fR . */
9973 #ifdef JITTER_HAVE_PATCH_IN
9974   /* Define argument-access macros assuming that fast branches are enabled. */
9975     /* The 0th argument is a "residual" fast label.  Define its
9976        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
9977        so that at replication time we know what instruction address to patch in. */
9978 #   define JITTER_ARGF0 0
9979     /* JITTER_ARG0 is intentionally not defined for a fast label. */
9980 
9981 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9982 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9983 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9984 
9985 #else
9986   /* Define argument-access macros assuming that fast branches are disabled. */
9987 #if defined(JITTER_DISPATCH_NO_THREADING)
9988 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
9989     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9990 #elif defined (JITTER_REPLICATE)
9991 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
9992 #else
9993 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
9994 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9995 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9996 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9997 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9998 #   define JITTER_ARGF0 JITTER_ARGP0
9999 
10000 # endif // #ifdef JITTER_HAVE_PATCH_IN
10001 
10002 #if defined (JITTER_PROFILE_SAMPLE)
10003   JITTER_PROFILE_SAMPLE_UPDATE
10004      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10005       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10006   /* Force the compiler not move sample-profiling instrumentation
10007      beyond this point; this way the actual user code is timed.
10008      This is still not perfect, as residuals are materialised before
10009      we arrive here, but should be adequate at least for slow VM
10010      instructions. */
10011   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10012 #endif
10013 #if defined (JITTER_PROFILE_COUNT)
10014   /* Notice that, differently from the code above, this
10015      instrumentation code *can* be reordered freely: as long as a
10016      VM instruction is counted, the count increment can be placed
10017      anyehere.  Let GCC move this code and possibly achieve better
10018      throughput by exploiting instruction-level parallelism and
10019      therefore approximate more closely a non-profiled build. */
10020   JITTER_PROFILE_COUNT_UPDATE
10021      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10022       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10023 #endif
10024 
10025 /* User-specified code, instruction-beginning-c part: beginning. */
10026 
10027 /* User-specified code, instruction-beginning-c part: end */
10028 
10029 
10030     /* User code for bzlu/fR . */
10031 #line 3672 "../../libpoke/pvm.jitter"
10032 
10033     pvm_val tmp = JITTER_TOP_STACK ();
10034     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_ULONG (tmp), JITTER_ARGF0);
10035 
10036     /* End of the user code for bzlu/fR . */
10037 
10038 /* User-specified code, instruction-end-c part: beginning. */
10039 
10040 /* User-specified code, instruction-end-c part: end */
10041 
10042     /* Undefine the bzlu/fR argument macros so they can't be used
10043        by mistake in the instruction body coming next. */
10044 #   undef JITTER_SLOW_REGISTER_OFFSET0
10045 #   undef JITTER_ARG0
10046 #   undef JITTER_ARGN0
10047 #   undef JITTER_ARGU0
10048 #   undef JITTER_ARGP0
10049 #   undef JITTER_ARGF0
10050 
10051 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10052 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10053 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10054 
10055   }
10056  JITTER_INSTRUCTION_EPILOG_(bzlu/fR, bzlu__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10057 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10058 
10059   JITTER_INSTRUCTION_PROLOG_(call/retR, call__retR, hot)
10060   {
10061     /* This specialized instruction is not a replacement. */
10062 #   undef JITTER_BRANCH_FAST
10063 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10064 #   undef JITTER_BRANCH_FAST_IF_ZERO
10065 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10066 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10067 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10068 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10069 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10070 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10071 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10072 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10073 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10074 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10075 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10076 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10077 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10078 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10079 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10080 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10081 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10082 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10083 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10084 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10085 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10086 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10087 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10088 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10089 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10090 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10091 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10092 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10093 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10094 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10095 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10096 #   undef JITTER_BRANCH_FAST_IF_AND
10097 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10098 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10099 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10100 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10101 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10102 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10103 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10104 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10105 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10106 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10107 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10108 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10109 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10110 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10111 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10112 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10113 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10114 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10115 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10116 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10117 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10118 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10119 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10120 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10121 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10122 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10123 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10124 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10125 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10126     /* This specialized instruction is a caller.
10127        Its 0-th argument, a literal, is the return address where to jump
10128        back after the procedure returns.  Branch-and-link
10129        functionality is enabled for this instruction. */
10130 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
10131 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10132 
10133 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       57
10134 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/retR
10135 
10136 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__retR
10137 
10138   /* The residual arity for this instruction does not depend on fast labels. */
10139   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
10140 
10141     /* The 0th argument is a residual literal. */
10142 #if defined(JITTER_DISPATCH_NO_THREADING)
10143 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
10144     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
10145 #elif defined (JITTER_REPLICATE)
10146 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
10147 #else
10148 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
10149 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
10150 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
10151 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
10152 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
10153 #   define JITTER_ARGF0 JITTER_ARGP0
10154 
10155 
10156 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10157     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10158   /* We use the implicit atgument at the end of the calling.
10159      instruction to discover the procedure return address. */
10160   const void * _jitter_return_pointer = JITTER_ARGP0;
10161   /* And make it accessible to the user (who will usually call
10162      JITTER_BRANCH_AND_LINK) thru a nice macro. */
10163 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
10164 #endif
10165 
10166 #if defined (JITTER_PROFILE_SAMPLE)
10167   JITTER_PROFILE_SAMPLE_UPDATE
10168      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10169       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10170   /* Force the compiler not move sample-profiling instrumentation
10171      beyond this point; this way the actual user code is timed.
10172      This is still not perfect, as residuals are materialised before
10173      we arrive here, but should be adequate at least for slow VM
10174      instructions. */
10175   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10176 #endif
10177 #if defined (JITTER_PROFILE_COUNT)
10178   /* Notice that, differently from the code above, this
10179      instrumentation code *can* be reordered freely: as long as a
10180      VM instruction is counted, the count increment can be placed
10181      anyehere.  Let GCC move this code and possibly achieve better
10182      throughput by exploiting instruction-level parallelism and
10183      therefore approximate more closely a non-profiled build. */
10184   JITTER_PROFILE_COUNT_UPDATE
10185      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10186       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10187 #endif
10188 
10189 /* User-specified code, instruction-beginning-c part: beginning. */
10190 
10191 /* User-specified code, instruction-beginning-c part: end */
10192 
10193 
10194     /* User code for call/retR . */
10195 #line 1551 "../../libpoke/pvm.jitter"
10196 
10197     pvm_val closure = JITTER_TOP_STACK ();
10198 
10199     assert (PVM_VAL_CLS_ENV (closure) != NULL);
10200     JITTER_DROP_STACK ();
10201     PVM_CALL (closure);
10202 
10203     /* End of the user code for call/retR . */
10204 
10205 /* User-specified code, instruction-end-c part: beginning. */
10206 
10207 /* User-specified code, instruction-end-c part: end */
10208 
10209     /* Undefine macros only visible in caller instructions. */
10210 #   undef JITTER_BRANCH_AND_LINK
10211 #   undef JITTER_BRANCH_FAST_AND_LINK
10212 
10213     /* Undefine the call/retR argument macros so they can't be used
10214        by mistake in the instruction body coming next. */
10215 #   undef JITTER_SLOW_REGISTER_OFFSET0
10216 #   undef JITTER_ARG0
10217 #   undef JITTER_ARGN0
10218 #   undef JITTER_ARGU0
10219 #   undef JITTER_ARGP0
10220 #   undef JITTER_ARGF0
10221 
10222 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10223 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10224 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10225 
10226   }
10227 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10228     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10229 # undef JITTER_RETURN_ADDRESS
10230 #endif
10231 
10232  JITTER_INSTRUCTION_EPILOG_(call/retR, call__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10233 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10234 
10235   JITTER_INSTRUCTION_PROLOG_(canary, canary, hot)
10236   {
10237     /* This specialized instruction is not a replacement. */
10238 #   undef JITTER_BRANCH_FAST
10239 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10240 #   undef JITTER_BRANCH_FAST_IF_ZERO
10241 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10242 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10243 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10244 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10245 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10246 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10247 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10248 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10249 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10250 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10251 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10252 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10253 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10254 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10255 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10256 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10257 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10258 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10259 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10260 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10261 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10262 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10263 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10264 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10265 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10266 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10267 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10268 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10269 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10270 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10271 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10272 #   undef JITTER_BRANCH_FAST_IF_AND
10273 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10274 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10275 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10276 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10277 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10278 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10279 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10280 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10281 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10282 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10283 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10284 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10285 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10286 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10287 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10288 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10289 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10290 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10291 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10292 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10293 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10294 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10295 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10296 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10297 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10298 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10299 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10300 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10301 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10302 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       58
10303 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         canary
10304 
10305 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME canary
10306 
10307   /* The residual arity for this instruction does not depend on fast labels. */
10308   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
10309 
10310 
10311 #if defined (JITTER_PROFILE_SAMPLE)
10312   JITTER_PROFILE_SAMPLE_UPDATE
10313      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10314       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10315   /* Force the compiler not move sample-profiling instrumentation
10316      beyond this point; this way the actual user code is timed.
10317      This is still not perfect, as residuals are materialised before
10318      we arrive here, but should be adequate at least for slow VM
10319      instructions. */
10320   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10321 #endif
10322 #if defined (JITTER_PROFILE_COUNT)
10323   /* Notice that, differently from the code above, this
10324      instrumentation code *can* be reordered freely: as long as a
10325      VM instruction is counted, the count increment can be placed
10326      anyehere.  Let GCC move this code and possibly achieve better
10327      throughput by exploiting instruction-level parallelism and
10328      therefore approximate more closely a non-profiled build. */
10329   JITTER_PROFILE_COUNT_UPDATE
10330      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10331       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10332 #endif
10333 
10334 /* User-specified code, instruction-beginning-c part: beginning. */
10335 
10336 /* User-specified code, instruction-beginning-c part: end */
10337 
10338 
10339     /* User code for canary . */
10340 #line 877 "../../libpoke/pvm.jitter"
10341 
10342      JITTER_STATE_BACKING_FIELD (canary) = JITTER_HEIGHT_STACK ();
10343 
10344     /* End of the user code for canary . */
10345 
10346 /* User-specified code, instruction-end-c part: beginning. */
10347 
10348 /* User-specified code, instruction-end-c part: end */
10349 
10350     /* Undefine the canary argument macros so they can't be used
10351        by mistake in the instruction body coming next. */
10352 
10353 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10354 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10355 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10356 
10357   }
10358  JITTER_INSTRUCTION_EPILOG_(canary, canary, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10359 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10360 
10361   JITTER_INSTRUCTION_PROLOG_(close, close, hot)
10362   {
10363     /* This specialized instruction is not a replacement. */
10364 #   undef JITTER_BRANCH_FAST
10365 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10366 #   undef JITTER_BRANCH_FAST_IF_ZERO
10367 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10368 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10369 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10370 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10371 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10372 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10373 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10374 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10375 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10376 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10377 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10378 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10379 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10380 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10381 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10382 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10383 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10384 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10385 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10386 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10387 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10388 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10389 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10390 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10391 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10392 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10393 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10394 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10395 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10396 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10397 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10398 #   undef JITTER_BRANCH_FAST_IF_AND
10399 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10400 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10401 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10402 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10403 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10404 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10405 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10406 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10407 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10408 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10409 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10410 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10411 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10412 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10413 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10414 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10415 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10416 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10417 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10418 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10419 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10420 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10421 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10422 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10423 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10424 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10425 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10426 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10427 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10428 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       59
10429 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         close
10430 
10431 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME close
10432 
10433   /* The residual arity for this instruction does not depend on fast labels. */
10434   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
10435 
10436 
10437 #if defined (JITTER_PROFILE_SAMPLE)
10438   JITTER_PROFILE_SAMPLE_UPDATE
10439      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10440       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10441   /* Force the compiler not move sample-profiling instrumentation
10442      beyond this point; this way the actual user code is timed.
10443      This is still not perfect, as residuals are materialised before
10444      we arrive here, but should be adequate at least for slow VM
10445      instructions. */
10446   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10447 #endif
10448 #if defined (JITTER_PROFILE_COUNT)
10449   /* Notice that, differently from the code above, this
10450      instrumentation code *can* be reordered freely: as long as a
10451      VM instruction is counted, the count increment can be placed
10452      anyehere.  Let GCC move this code and possibly achieve better
10453      throughput by exploiting instruction-level parallelism and
10454      therefore approximate more closely a non-profiled build. */
10455   JITTER_PROFILE_COUNT_UPDATE
10456      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10457       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10458 #endif
10459 
10460 /* User-specified code, instruction-beginning-c part: beginning. */
10461 
10462 /* User-specified code, instruction-beginning-c part: end */
10463 
10464 
10465     /* User code for close . */
10466 #line 1382 "../../libpoke/pvm.jitter"
10467 
10468     int io_id = PVM_VAL_INT (JITTER_TOP_STACK ());
10469     ios io = ios_search_by_id (io_id);
10470 
10471     if (io == NULL)
10472       PVM_RAISE_DFL (PVM_E_IO);
10473 
10474     ios_close (io);
10475     JITTER_DROP_STACK ();
10476 
10477     /* End of the user code for close . */
10478 
10479 /* User-specified code, instruction-end-c part: beginning. */
10480 
10481 /* User-specified code, instruction-end-c part: end */
10482 
10483     /* Undefine the close argument macros so they can't be used
10484        by mistake in the instruction body coming next. */
10485 
10486 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10487 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10488 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10489 
10490   }
10491  JITTER_INSTRUCTION_EPILOG_(close, close, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10492 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10493 
10494   JITTER_INSTRUCTION_PROLOG_(ctos, ctos, hot)
10495   {
10496     /* This specialized instruction is not a replacement. */
10497 #   undef JITTER_BRANCH_FAST
10498 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10499 #   undef JITTER_BRANCH_FAST_IF_ZERO
10500 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10501 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10502 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10503 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10504 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10505 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10506 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10507 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10508 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10509 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10510 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10511 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10512 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10513 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10514 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10515 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10516 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10517 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10518 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10519 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10520 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10521 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10522 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10523 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10524 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10525 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10526 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10527 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10528 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10529 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10530 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10531 #   undef JITTER_BRANCH_FAST_IF_AND
10532 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10533 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10534 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10535 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10536 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10537 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10538 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10539 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10540 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10541 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10542 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10543 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10544 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10545 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10546 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10547 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10548 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10549 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10550 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10551 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10552 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10553 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10554 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10555 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10556 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10557 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10558 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10559 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10560 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10561 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       60
10562 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ctos
10563 
10564 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ctos
10565 
10566   /* The residual arity for this instruction does not depend on fast labels. */
10567   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
10568 
10569 
10570 #if defined (JITTER_PROFILE_SAMPLE)
10571   JITTER_PROFILE_SAMPLE_UPDATE
10572      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10573       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10574   /* Force the compiler not move sample-profiling instrumentation
10575      beyond this point; this way the actual user code is timed.
10576      This is still not perfect, as residuals are materialised before
10577      we arrive here, but should be adequate at least for slow VM
10578      instructions. */
10579   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10580 #endif
10581 #if defined (JITTER_PROFILE_COUNT)
10582   /* Notice that, differently from the code above, this
10583      instrumentation code *can* be reordered freely: as long as a
10584      VM instruction is counted, the count increment can be placed
10585      anyehere.  Let GCC move this code and possibly achieve better
10586      throughput by exploiting instruction-level parallelism and
10587      therefore approximate more closely a non-profiled build. */
10588   JITTER_PROFILE_COUNT_UPDATE
10589      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10590       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10591 #endif
10592 
10593 /* User-specified code, instruction-beginning-c part: beginning. */
10594 
10595 /* User-specified code, instruction-beginning-c part: end */
10596 
10597 
10598     /* User code for ctos . */
10599 #line 3745 "../../libpoke/pvm.jitter"
10600 
10601     uint8_t c = PVM_VAL_UINT (JITTER_TOP_STACK ());
10602     char *str = pvm_alloc (2);
10603     str[0] = c;
10604     str[1] = '\0';
10605 
10606     JITTER_PUSH_STACK (pvm_make_string (str));
10607 
10608     /* End of the user code for ctos . */
10609 
10610 /* User-specified code, instruction-end-c part: beginning. */
10611 
10612 /* User-specified code, instruction-end-c part: end */
10613 
10614     /* Undefine the ctos argument macros so they can't be used
10615        by mistake in the instruction body coming next. */
10616 
10617 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10618 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10619 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10620 
10621   }
10622  JITTER_INSTRUCTION_EPILOG_(ctos, ctos, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10623 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10624 
10625   JITTER_INSTRUCTION_PROLOG_(disas, disas, hot)
10626   {
10627     /* This specialized instruction is not a replacement. */
10628 #   undef JITTER_BRANCH_FAST
10629 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10630 #   undef JITTER_BRANCH_FAST_IF_ZERO
10631 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10632 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10633 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10634 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10635 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10636 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10637 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10638 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10639 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10640 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10641 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10642 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10643 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10644 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10645 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10646 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10647 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10648 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10649 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10650 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10651 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10652 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10653 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10654 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10655 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10656 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10657 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10658 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10659 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10660 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10661 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10662 #   undef JITTER_BRANCH_FAST_IF_AND
10663 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10664 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10665 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10666 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10667 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10668 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10669 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10670 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10671 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10672 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10673 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10674 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10675 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10676 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10677 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10678 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10679 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10680 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10681 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10682 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10683 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10684 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10685 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10686 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10687 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10688 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10689 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10690 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10691 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10692 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       61
10693 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         disas
10694 
10695 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME disas
10696 
10697   /* The residual arity for this instruction does not depend on fast labels. */
10698   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
10699 
10700 
10701 #if defined (JITTER_PROFILE_SAMPLE)
10702   JITTER_PROFILE_SAMPLE_UPDATE
10703      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10704       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10705   /* Force the compiler not move sample-profiling instrumentation
10706      beyond this point; this way the actual user code is timed.
10707      This is still not perfect, as residuals are materialised before
10708      we arrive here, but should be adequate at least for slow VM
10709      instructions. */
10710   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10711 #endif
10712 #if defined (JITTER_PROFILE_COUNT)
10713   /* Notice that, differently from the code above, this
10714      instrumentation code *can* be reordered freely: as long as a
10715      VM instruction is counted, the count increment can be placed
10716      anyehere.  Let GCC move this code and possibly achieve better
10717      throughput by exploiting instruction-level parallelism and
10718      therefore approximate more closely a non-profiled build. */
10719   JITTER_PROFILE_COUNT_UPDATE
10720      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10721       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10722 #endif
10723 
10724 /* User-specified code, instruction-beginning-c part: beginning. */
10725 
10726 /* User-specified code, instruction-beginning-c part: end */
10727 
10728 
10729     /* User code for disas . */
10730 #line 5652 "../../libpoke/pvm.jitter"
10731 
10732     pvm_val cls = JITTER_TOP_STACK ();
10733     pvm_disassemble_program (PVM_VAL_CLS_PROGRAM (cls));
10734 
10735     /* End of the user code for disas . */
10736 
10737 /* User-specified code, instruction-end-c part: beginning. */
10738 
10739 /* User-specified code, instruction-end-c part: end */
10740 
10741     /* Undefine the disas argument macros so they can't be used
10742        by mistake in the instruction body coming next. */
10743 
10744 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10745 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10746 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10747 
10748   }
10749  JITTER_INSTRUCTION_EPILOG_(disas, disas, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10750 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10751 
10752   JITTER_INSTRUCTION_PROLOG_(divi, divi, hot)
10753   {
10754     /* This specialized instruction is not a replacement. */
10755 #   undef JITTER_BRANCH_FAST
10756 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10757 #   undef JITTER_BRANCH_FAST_IF_ZERO
10758 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10759 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10760 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10761 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10762 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10763 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10764 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10765 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10766 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10767 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10768 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10769 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10770 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10771 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10772 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10773 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10774 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10775 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10776 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10777 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10778 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10779 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10780 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10781 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10782 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10783 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10784 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10785 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10786 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10787 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10788 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10789 #   undef JITTER_BRANCH_FAST_IF_AND
10790 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10791 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10792 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10793 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10794 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10795 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10796 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10797 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10798 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10799 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10800 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10801 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10802 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10803 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10804 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10805 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10806 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10807 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10808 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10809 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10810 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10811 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10812 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10813 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10814 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10815 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10816 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10817 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10818 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10819 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       62
10820 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         divi
10821 
10822 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME divi
10823 
10824   /* The residual arity for this instruction does not depend on fast labels. */
10825   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
10826 
10827 
10828 #if defined (JITTER_PROFILE_SAMPLE)
10829   JITTER_PROFILE_SAMPLE_UPDATE
10830      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10831       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10832   /* Force the compiler not move sample-profiling instrumentation
10833      beyond this point; this way the actual user code is timed.
10834      This is still not perfect, as residuals are materialised before
10835      we arrive here, but should be adequate at least for slow VM
10836      instructions. */
10837   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10838 #endif
10839 #if defined (JITTER_PROFILE_COUNT)
10840   /* Notice that, differently from the code above, this
10841      instrumentation code *can* be reordered freely: as long as a
10842      VM instruction is counted, the count increment can be placed
10843      anyehere.  Let GCC move this code and possibly achieve better
10844      throughput by exploiting instruction-level parallelism and
10845      therefore approximate more closely a non-profiled build. */
10846   JITTER_PROFILE_COUNT_UPDATE
10847      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10848       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10849 #endif
10850 
10851 /* User-specified code, instruction-beginning-c part: beginning. */
10852 
10853 /* User-specified code, instruction-beginning-c part: end */
10854 
10855 
10856     /* User code for divi . */
10857 #line 2456 "../../libpoke/pvm.jitter"
10858 
10859     PVM_DIV_SIGNED (INT, int);
10860 
10861     /* End of the user code for divi . */
10862 
10863 /* User-specified code, instruction-end-c part: beginning. */
10864 
10865 /* User-specified code, instruction-end-c part: end */
10866 
10867     /* Undefine the divi argument macros so they can't be used
10868        by mistake in the instruction body coming next. */
10869 
10870 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10871 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10872 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10873 
10874   }
10875  JITTER_INSTRUCTION_EPILOG_(divi, divi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10876 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10877 
10878   JITTER_INSTRUCTION_PROLOG_(diviu, diviu, hot)
10879   {
10880     /* This specialized instruction is not a replacement. */
10881 #   undef JITTER_BRANCH_FAST
10882 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10883 #   undef JITTER_BRANCH_FAST_IF_ZERO
10884 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10885 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10886 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10887 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10888 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10889 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10890 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10891 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10892 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10893 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10894 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10895 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10896 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10897 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10898 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10899 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10900 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10901 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10902 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10903 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10904 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10905 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10906 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10907 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10908 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10909 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10910 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10911 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10912 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10913 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10914 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10915 #   undef JITTER_BRANCH_FAST_IF_AND
10916 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10917 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10918 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10919 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10920 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10921 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10922 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10923 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10924 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10925 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10926 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10927 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10928 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10929 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10930 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10931 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10932 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10933 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10934 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10935 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10936 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10937 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10938 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10939 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10940 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10941 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10942 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10943 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10944 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10945 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       63
10946 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         diviu
10947 
10948 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME diviu
10949 
10950   /* The residual arity for this instruction does not depend on fast labels. */
10951   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
10952 
10953 
10954 #if defined (JITTER_PROFILE_SAMPLE)
10955   JITTER_PROFILE_SAMPLE_UPDATE
10956      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10957       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10958   /* Force the compiler not move sample-profiling instrumentation
10959      beyond this point; this way the actual user code is timed.
10960      This is still not perfect, as residuals are materialised before
10961      we arrive here, but should be adequate at least for slow VM
10962      instructions. */
10963   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10964 #endif
10965 #if defined (JITTER_PROFILE_COUNT)
10966   /* Notice that, differently from the code above, this
10967      instrumentation code *can* be reordered freely: as long as a
10968      VM instruction is counted, the count increment can be placed
10969      anyehere.  Let GCC move this code and possibly achieve better
10970      throughput by exploiting instruction-level parallelism and
10971      therefore approximate more closely a non-profiled build. */
10972   JITTER_PROFILE_COUNT_UPDATE
10973      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10974       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10975 #endif
10976 
10977 /* User-specified code, instruction-beginning-c part: beginning. */
10978 
10979 /* User-specified code, instruction-beginning-c part: end */
10980 
10981 
10982     /* User code for diviu . */
10983 #line 2471 "../../libpoke/pvm.jitter"
10984 
10985     PVM_CHECKED_BINOP (UINT, UINT, UINT, /);
10986 
10987     /* End of the user code for diviu . */
10988 
10989 /* User-specified code, instruction-end-c part: beginning. */
10990 
10991 /* User-specified code, instruction-end-c part: end */
10992 
10993     /* Undefine the diviu argument macros so they can't be used
10994        by mistake in the instruction body coming next. */
10995 
10996 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10997 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10998 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10999 
11000   }
11001  JITTER_INSTRUCTION_EPILOG_(diviu, diviu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11002 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11003 
11004   JITTER_INSTRUCTION_PROLOG_(divl, divl, hot)
11005   {
11006     /* This specialized instruction is not a replacement. */
11007 #   undef JITTER_BRANCH_FAST
11008 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11009 #   undef JITTER_BRANCH_FAST_IF_ZERO
11010 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11011 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11012 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11013 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11014 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11015 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11016 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11017 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11018 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11019 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11020 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11021 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11022 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11023 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11024 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11025 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11026 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11027 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11028 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11029 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11030 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11031 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11032 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11033 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11034 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11035 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11036 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11037 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11038 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11039 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11040 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11041 #   undef JITTER_BRANCH_FAST_IF_AND
11042 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11043 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11044 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11045 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11046 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11047 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11048 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11049 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11050 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11051 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11052 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11053 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11054 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11055 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11056 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11057 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11058 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11059 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11060 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11061 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11062 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11063 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11064 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11065 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11066 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11067 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11068 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11069 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11070 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11071 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       64
11072 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         divl
11073 
11074 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME divl
11075 
11076   /* The residual arity for this instruction does not depend on fast labels. */
11077   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11078 
11079 
11080 #if defined (JITTER_PROFILE_SAMPLE)
11081   JITTER_PROFILE_SAMPLE_UPDATE
11082      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11083       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11084   /* Force the compiler not move sample-profiling instrumentation
11085      beyond this point; this way the actual user code is timed.
11086      This is still not perfect, as residuals are materialised before
11087      we arrive here, but should be adequate at least for slow VM
11088      instructions. */
11089   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11090 #endif
11091 #if defined (JITTER_PROFILE_COUNT)
11092   /* Notice that, differently from the code above, this
11093      instrumentation code *can* be reordered freely: as long as a
11094      VM instruction is counted, the count increment can be placed
11095      anyehere.  Let GCC move this code and possibly achieve better
11096      throughput by exploiting instruction-level parallelism and
11097      therefore approximate more closely a non-profiled build. */
11098   JITTER_PROFILE_COUNT_UPDATE
11099      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11100       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11101 #endif
11102 
11103 /* User-specified code, instruction-beginning-c part: beginning. */
11104 
11105 /* User-specified code, instruction-beginning-c part: end */
11106 
11107 
11108     /* User code for divl . */
11109 #line 2485 "../../libpoke/pvm.jitter"
11110 
11111     PVM_DIV_SIGNED (LONG, int64_t);
11112 
11113     /* End of the user code for divl . */
11114 
11115 /* User-specified code, instruction-end-c part: beginning. */
11116 
11117 /* User-specified code, instruction-end-c part: end */
11118 
11119     /* Undefine the divl argument macros so they can't be used
11120        by mistake in the instruction body coming next. */
11121 
11122 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11123 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11124 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11125 
11126   }
11127  JITTER_INSTRUCTION_EPILOG_(divl, divl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11128 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11129 
11130   JITTER_INSTRUCTION_PROLOG_(divlu, divlu, hot)
11131   {
11132     /* This specialized instruction is not a replacement. */
11133 #   undef JITTER_BRANCH_FAST
11134 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11135 #   undef JITTER_BRANCH_FAST_IF_ZERO
11136 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11137 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11138 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11139 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11140 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11141 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11142 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11143 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11144 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11145 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11146 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11147 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11148 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11149 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11150 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11151 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11152 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11153 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11154 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11155 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11156 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11157 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11158 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11159 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11160 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11161 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11162 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11163 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11164 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11165 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11166 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11167 #   undef JITTER_BRANCH_FAST_IF_AND
11168 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11169 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11170 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11171 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11172 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11173 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11174 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11175 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11176 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11177 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11178 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11179 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11180 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11181 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11182 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11183 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11184 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11185 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11186 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11187 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11188 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11189 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11190 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11191 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11192 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11193 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11194 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11195 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11196 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11197 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       65
11198 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         divlu
11199 
11200 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME divlu
11201 
11202   /* The residual arity for this instruction does not depend on fast labels. */
11203   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11204 
11205 
11206 #if defined (JITTER_PROFILE_SAMPLE)
11207   JITTER_PROFILE_SAMPLE_UPDATE
11208      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11209       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11210   /* Force the compiler not move sample-profiling instrumentation
11211      beyond this point; this way the actual user code is timed.
11212      This is still not perfect, as residuals are materialised before
11213      we arrive here, but should be adequate at least for slow VM
11214      instructions. */
11215   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11216 #endif
11217 #if defined (JITTER_PROFILE_COUNT)
11218   /* Notice that, differently from the code above, this
11219      instrumentation code *can* be reordered freely: as long as a
11220      VM instruction is counted, the count increment can be placed
11221      anyehere.  Let GCC move this code and possibly achieve better
11222      throughput by exploiting instruction-level parallelism and
11223      therefore approximate more closely a non-profiled build. */
11224   JITTER_PROFILE_COUNT_UPDATE
11225      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11226       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11227 #endif
11228 
11229 /* User-specified code, instruction-beginning-c part: beginning. */
11230 
11231 /* User-specified code, instruction-beginning-c part: end */
11232 
11233 
11234     /* User code for divlu . */
11235 #line 2500 "../../libpoke/pvm.jitter"
11236 
11237     PVM_CHECKED_BINOP (ULONG, ULONG, ULONG, /);
11238 
11239     /* End of the user code for divlu . */
11240 
11241 /* User-specified code, instruction-end-c part: beginning. */
11242 
11243 /* User-specified code, instruction-end-c part: end */
11244 
11245     /* Undefine the divlu argument macros so they can't be used
11246        by mistake in the instruction body coming next. */
11247 
11248 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11249 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11250 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11251 
11252   }
11253  JITTER_INSTRUCTION_EPILOG_(divlu, divlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11254 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11255 
11256   JITTER_INSTRUCTION_PROLOG_(drop, drop, hot)
11257   {
11258     /* This specialized instruction is not a replacement. */
11259 #   undef JITTER_BRANCH_FAST
11260 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11261 #   undef JITTER_BRANCH_FAST_IF_ZERO
11262 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11263 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11264 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11265 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11266 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11267 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11268 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11269 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11270 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11271 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11272 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11273 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11274 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11275 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11276 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11277 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11278 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11279 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11280 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11281 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11282 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11283 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11284 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11285 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11286 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11287 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11288 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11289 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11290 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11291 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11292 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11293 #   undef JITTER_BRANCH_FAST_IF_AND
11294 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11295 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11296 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11297 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11298 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11299 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11300 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11301 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11302 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11303 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11304 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11305 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11306 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11307 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11308 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11309 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11310 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11311 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11312 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11313 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11314 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11315 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11316 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11317 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11318 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11319 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11320 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11321 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11322 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11323 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       66
11324 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop
11325 
11326 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop
11327 
11328   /* The residual arity for this instruction does not depend on fast labels. */
11329   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11330 
11331 
11332 #if defined (JITTER_PROFILE_SAMPLE)
11333   JITTER_PROFILE_SAMPLE_UPDATE
11334      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11335       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11336   /* Force the compiler not move sample-profiling instrumentation
11337      beyond this point; this way the actual user code is timed.
11338      This is still not perfect, as residuals are materialised before
11339      we arrive here, but should be adequate at least for slow VM
11340      instructions. */
11341   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11342 #endif
11343 #if defined (JITTER_PROFILE_COUNT)
11344   /* Notice that, differently from the code above, this
11345      instrumentation code *can* be reordered freely: as long as a
11346      VM instruction is counted, the count increment can be placed
11347      anyehere.  Let GCC move this code and possibly achieve better
11348      throughput by exploiting instruction-level parallelism and
11349      therefore approximate more closely a non-profiled build. */
11350   JITTER_PROFILE_COUNT_UPDATE
11351      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11352       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11353 #endif
11354 
11355 /* User-specified code, instruction-beginning-c part: beginning. */
11356 
11357 /* User-specified code, instruction-beginning-c part: end */
11358 
11359 
11360     /* User code for drop . */
11361 #line 1931 "../../libpoke/pvm.jitter"
11362 
11363     JITTER_DROP_STACK();
11364 
11365     /* End of the user code for drop . */
11366 
11367 /* User-specified code, instruction-end-c part: beginning. */
11368 
11369 /* User-specified code, instruction-end-c part: end */
11370 
11371     /* Undefine the drop argument macros so they can't be used
11372        by mistake in the instruction body coming next. */
11373 
11374 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11375 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11376 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11377 
11378   }
11379  JITTER_INSTRUCTION_EPILOG_(drop, drop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11380 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11381 
11382   JITTER_INSTRUCTION_PROLOG_(drop2, drop2, hot)
11383   {
11384     /* This specialized instruction is not a replacement. */
11385 #   undef JITTER_BRANCH_FAST
11386 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11387 #   undef JITTER_BRANCH_FAST_IF_ZERO
11388 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11389 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11390 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11391 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11392 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11393 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11394 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11395 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11396 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11397 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11398 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11399 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11400 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11401 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11402 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11403 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11404 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11405 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11406 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11407 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11408 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11409 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11410 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11411 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11412 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11413 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11414 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11415 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11416 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11417 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11418 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11419 #   undef JITTER_BRANCH_FAST_IF_AND
11420 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11421 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11422 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11423 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11424 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11425 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11426 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11427 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11428 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11429 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11430 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11431 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11432 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11433 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11434 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11435 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11436 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11437 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11438 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11439 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11440 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11441 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11442 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11443 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11444 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11445 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11446 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11447 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11448 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11449 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       67
11450 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop2
11451 
11452 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop2
11453 
11454   /* The residual arity for this instruction does not depend on fast labels. */
11455   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11456 
11457 
11458 #if defined (JITTER_PROFILE_SAMPLE)
11459   JITTER_PROFILE_SAMPLE_UPDATE
11460      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11461       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11462   /* Force the compiler not move sample-profiling instrumentation
11463      beyond this point; this way the actual user code is timed.
11464      This is still not perfect, as residuals are materialised before
11465      we arrive here, but should be adequate at least for slow VM
11466      instructions. */
11467   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11468 #endif
11469 #if defined (JITTER_PROFILE_COUNT)
11470   /* Notice that, differently from the code above, this
11471      instrumentation code *can* be reordered freely: as long as a
11472      VM instruction is counted, the count increment can be placed
11473      anyehere.  Let GCC move this code and possibly achieve better
11474      throughput by exploiting instruction-level parallelism and
11475      therefore approximate more closely a non-profiled build. */
11476   JITTER_PROFILE_COUNT_UPDATE
11477      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11478       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11479 #endif
11480 
11481 /* User-specified code, instruction-beginning-c part: beginning. */
11482 
11483 /* User-specified code, instruction-beginning-c part: end */
11484 
11485 
11486     /* User code for drop2 . */
11487 #line 1943 "../../libpoke/pvm.jitter"
11488 
11489     JITTER_DROP_STACK();
11490     JITTER_DROP_STACK();
11491 
11492     /* End of the user code for drop2 . */
11493 
11494 /* User-specified code, instruction-end-c part: beginning. */
11495 
11496 /* User-specified code, instruction-end-c part: end */
11497 
11498     /* Undefine the drop2 argument macros so they can't be used
11499        by mistake in the instruction body coming next. */
11500 
11501 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11502 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11503 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11504 
11505   }
11506  JITTER_INSTRUCTION_EPILOG_(drop2, drop2, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11507 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11508 
11509   JITTER_INSTRUCTION_PROLOG_(drop3, drop3, hot)
11510   {
11511     /* This specialized instruction is not a replacement. */
11512 #   undef JITTER_BRANCH_FAST
11513 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11514 #   undef JITTER_BRANCH_FAST_IF_ZERO
11515 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11516 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11517 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11518 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11519 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11520 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11521 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11522 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11523 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11524 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11525 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11526 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11527 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11528 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11529 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11530 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11531 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11532 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11533 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11534 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11535 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11536 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11537 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11538 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11539 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11540 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11541 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11542 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11543 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11544 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11545 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11546 #   undef JITTER_BRANCH_FAST_IF_AND
11547 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11548 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11549 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11550 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11551 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11552 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11553 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11554 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11555 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11556 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11557 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11558 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11559 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11560 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11561 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11562 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11563 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11564 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11565 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11566 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11567 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11568 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11569 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11570 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11571 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11572 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11573 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11574 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11575 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11576 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       68
11577 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop3
11578 
11579 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop3
11580 
11581   /* The residual arity for this instruction does not depend on fast labels. */
11582   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11583 
11584 
11585 #if defined (JITTER_PROFILE_SAMPLE)
11586   JITTER_PROFILE_SAMPLE_UPDATE
11587      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11588       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11589   /* Force the compiler not move sample-profiling instrumentation
11590      beyond this point; this way the actual user code is timed.
11591      This is still not perfect, as residuals are materialised before
11592      we arrive here, but should be adequate at least for slow VM
11593      instructions. */
11594   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11595 #endif
11596 #if defined (JITTER_PROFILE_COUNT)
11597   /* Notice that, differently from the code above, this
11598      instrumentation code *can* be reordered freely: as long as a
11599      VM instruction is counted, the count increment can be placed
11600      anyehere.  Let GCC move this code and possibly achieve better
11601      throughput by exploiting instruction-level parallelism and
11602      therefore approximate more closely a non-profiled build. */
11603   JITTER_PROFILE_COUNT_UPDATE
11604      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11605       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11606 #endif
11607 
11608 /* User-specified code, instruction-beginning-c part: beginning. */
11609 
11610 /* User-specified code, instruction-beginning-c part: end */
11611 
11612 
11613     /* User code for drop3 . */
11614 #line 1956 "../../libpoke/pvm.jitter"
11615 
11616     JITTER_DROP_STACK();
11617     JITTER_DROP_STACK();
11618     JITTER_DROP_STACK();
11619 
11620     /* End of the user code for drop3 . */
11621 
11622 /* User-specified code, instruction-end-c part: beginning. */
11623 
11624 /* User-specified code, instruction-end-c part: end */
11625 
11626     /* Undefine the drop3 argument macros so they can't be used
11627        by mistake in the instruction body coming next. */
11628 
11629 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11630 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11631 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11632 
11633   }
11634  JITTER_INSTRUCTION_EPILOG_(drop3, drop3, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11635 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11636 
11637   JITTER_INSTRUCTION_PROLOG_(drop4, drop4, hot)
11638   {
11639     /* This specialized instruction is not a replacement. */
11640 #   undef JITTER_BRANCH_FAST
11641 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11642 #   undef JITTER_BRANCH_FAST_IF_ZERO
11643 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11644 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11645 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11646 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11647 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11648 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11649 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11650 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11651 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11652 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11653 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11654 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11655 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11656 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11657 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11658 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11659 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11660 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11661 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11662 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11663 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11664 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11665 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11666 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11667 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11668 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11669 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11670 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11671 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11672 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11673 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11674 #   undef JITTER_BRANCH_FAST_IF_AND
11675 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11676 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11677 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11678 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11679 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11680 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11681 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11682 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11683 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11684 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11685 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11686 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11687 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11688 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11689 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11690 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11691 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11692 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11693 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11694 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11695 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11696 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11697 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11698 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11699 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11700 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11701 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11702 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11703 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11704 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       69
11705 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop4
11706 
11707 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop4
11708 
11709   /* The residual arity for this instruction does not depend on fast labels. */
11710   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11711 
11712 
11713 #if defined (JITTER_PROFILE_SAMPLE)
11714   JITTER_PROFILE_SAMPLE_UPDATE
11715      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11716       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11717   /* Force the compiler not move sample-profiling instrumentation
11718      beyond this point; this way the actual user code is timed.
11719      This is still not perfect, as residuals are materialised before
11720      we arrive here, but should be adequate at least for slow VM
11721      instructions. */
11722   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11723 #endif
11724 #if defined (JITTER_PROFILE_COUNT)
11725   /* Notice that, differently from the code above, this
11726      instrumentation code *can* be reordered freely: as long as a
11727      VM instruction is counted, the count increment can be placed
11728      anyehere.  Let GCC move this code and possibly achieve better
11729      throughput by exploiting instruction-level parallelism and
11730      therefore approximate more closely a non-profiled build. */
11731   JITTER_PROFILE_COUNT_UPDATE
11732      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11733       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11734 #endif
11735 
11736 /* User-specified code, instruction-beginning-c part: beginning. */
11737 
11738 /* User-specified code, instruction-beginning-c part: end */
11739 
11740 
11741     /* User code for drop4 . */
11742 #line 1970 "../../libpoke/pvm.jitter"
11743 
11744     JITTER_DROP_STACK();
11745     JITTER_DROP_STACK();
11746     JITTER_DROP_STACK();
11747     JITTER_DROP_STACK();
11748 
11749     /* End of the user code for drop4 . */
11750 
11751 /* User-specified code, instruction-end-c part: beginning. */
11752 
11753 /* User-specified code, instruction-end-c part: end */
11754 
11755     /* Undefine the drop4 argument macros so they can't be used
11756        by mistake in the instruction body coming next. */
11757 
11758 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11759 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11760 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11761 
11762   }
11763  JITTER_INSTRUCTION_EPILOG_(drop4, drop4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11764 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11765 
11766   JITTER_INSTRUCTION_PROLOG_(duc, duc, hot)
11767   {
11768     /* This specialized instruction is not a replacement. */
11769 #   undef JITTER_BRANCH_FAST
11770 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11771 #   undef JITTER_BRANCH_FAST_IF_ZERO
11772 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11773 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11774 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11775 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11776 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11777 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11778 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11779 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11780 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11781 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11782 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11783 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11784 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11785 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11786 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11787 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11788 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11789 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11790 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11791 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11792 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11793 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11794 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11795 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11796 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11797 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11798 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11799 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11800 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11801 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11802 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11803 #   undef JITTER_BRANCH_FAST_IF_AND
11804 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11805 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11806 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11807 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11808 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11809 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11810 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11811 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11812 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11813 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11814 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11815 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11816 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11817 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11818 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11819 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11820 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11821 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11822 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11823 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11824 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11825 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11826 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11827 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11828 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11829 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11830 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11831 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11832 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11833 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       70
11834 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         duc
11835 
11836 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME duc
11837 
11838   /* The residual arity for this instruction does not depend on fast labels. */
11839   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11840 
11841 
11842 #if defined (JITTER_PROFILE_SAMPLE)
11843   JITTER_PROFILE_SAMPLE_UPDATE
11844      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11845       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11846   /* Force the compiler not move sample-profiling instrumentation
11847      beyond this point; this way the actual user code is timed.
11848      This is still not perfect, as residuals are materialised before
11849      we arrive here, but should be adequate at least for slow VM
11850      instructions. */
11851   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11852 #endif
11853 #if defined (JITTER_PROFILE_COUNT)
11854   /* Notice that, differently from the code above, this
11855      instrumentation code *can* be reordered freely: as long as a
11856      VM instruction is counted, the count increment can be placed
11857      anyehere.  Let GCC move this code and possibly achieve better
11858      throughput by exploiting instruction-level parallelism and
11859      therefore approximate more closely a non-profiled build. */
11860   JITTER_PROFILE_COUNT_UPDATE
11861      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11862       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11863 #endif
11864 
11865 /* User-specified code, instruction-beginning-c part: beginning. */
11866 
11867 /* User-specified code, instruction-beginning-c part: end */
11868 
11869 
11870     /* User code for duc . */
11871 #line 1718 "../../libpoke/pvm.jitter"
11872 
11873     pvm_val cls = JITTER_TOP_STACK ();
11874     pvm_val new_cls = pvm_make_cls (PVM_VAL_CLS_PROGRAM (cls));
11875 
11876     JITTER_DROP_STACK ();
11877     JITTER_PUSH_STACK (new_cls);
11878 
11879     /* End of the user code for duc . */
11880 
11881 /* User-specified code, instruction-end-c part: beginning. */
11882 
11883 /* User-specified code, instruction-end-c part: end */
11884 
11885     /* Undefine the duc argument macros so they can't be used
11886        by mistake in the instruction body coming next. */
11887 
11888 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11889 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11890 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11891 
11892   }
11893  JITTER_INSTRUCTION_EPILOG_(duc, duc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11894 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11895 
11896   JITTER_INSTRUCTION_PROLOG_(dup, dup, hot)
11897   {
11898     /* This specialized instruction is not a replacement. */
11899 #   undef JITTER_BRANCH_FAST
11900 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11901 #   undef JITTER_BRANCH_FAST_IF_ZERO
11902 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11903 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11904 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11905 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11906 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11907 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11908 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11909 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11910 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11911 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11912 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11913 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11914 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11915 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11916 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11917 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11918 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11919 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11920 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11921 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11922 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11923 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11924 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11925 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11926 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11927 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11928 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11929 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11930 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11931 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11932 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11933 #   undef JITTER_BRANCH_FAST_IF_AND
11934 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11935 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11936 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11937 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11938 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11939 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11940 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11941 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11942 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11943 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11944 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11945 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11946 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11947 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11948 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11949 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11950 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11951 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11952 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11953 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11954 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11955 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11956 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11957 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11958 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11959 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11960 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11961 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11962 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11963 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       71
11964 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         dup
11965 
11966 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME dup
11967 
11968   /* The residual arity for this instruction does not depend on fast labels. */
11969   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11970 
11971 
11972 #if defined (JITTER_PROFILE_SAMPLE)
11973   JITTER_PROFILE_SAMPLE_UPDATE
11974      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11975       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11976   /* Force the compiler not move sample-profiling instrumentation
11977      beyond this point; this way the actual user code is timed.
11978      This is still not perfect, as residuals are materialised before
11979      we arrive here, but should be adequate at least for slow VM
11980      instructions. */
11981   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11982 #endif
11983 #if defined (JITTER_PROFILE_COUNT)
11984   /* Notice that, differently from the code above, this
11985      instrumentation code *can* be reordered freely: as long as a
11986      VM instruction is counted, the count increment can be placed
11987      anyehere.  Let GCC move this code and possibly achieve better
11988      throughput by exploiting instruction-level parallelism and
11989      therefore approximate more closely a non-profiled build. */
11990   JITTER_PROFILE_COUNT_UPDATE
11991      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11992       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11993 #endif
11994 
11995 /* User-specified code, instruction-beginning-c part: beginning. */
11996 
11997 /* User-specified code, instruction-beginning-c part: end */
11998 
11999 
12000     /* User code for dup . */
12001 #line 2038 "../../libpoke/pvm.jitter"
12002 
12003     JITTER_DUP_STACK ();
12004 
12005     /* End of the user code for dup . */
12006 
12007 /* User-specified code, instruction-end-c part: beginning. */
12008 
12009 /* User-specified code, instruction-end-c part: end */
12010 
12011     /* Undefine the dup argument macros so they can't be used
12012        by mistake in the instruction body coming next. */
12013 
12014 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12015 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12016 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12017 
12018   }
12019  JITTER_INSTRUCTION_EPILOG_(dup, dup, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12020 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12021 
12022   JITTER_INSTRUCTION_PROLOG_(endhl, endhl, hot)
12023   {
12024     /* This specialized instruction is not a replacement. */
12025 #   undef JITTER_BRANCH_FAST
12026 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12027 #   undef JITTER_BRANCH_FAST_IF_ZERO
12028 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12029 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12030 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12031 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12032 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12033 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12034 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12035 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12036 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12037 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12038 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12039 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12040 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12041 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12042 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12043 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12044 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12045 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12046 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12047 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12048 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12049 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12050 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12051 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12052 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12053 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12054 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12055 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12056 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12057 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12058 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12059 #   undef JITTER_BRANCH_FAST_IF_AND
12060 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12061 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12062 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12063 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12064 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12065 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12066 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12067 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12068 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12069 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12070 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12071 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12072 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12073 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12074 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12075 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12076 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12077 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12078 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12079 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12080 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12081 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12082 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12083 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12084 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12085 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12086 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12087 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12088 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12089 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       72
12090 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         endhl
12091 
12092 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME endhl
12093 
12094   /* The residual arity for this instruction does not depend on fast labels. */
12095   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12096 
12097 
12098 #if defined (JITTER_PROFILE_SAMPLE)
12099   JITTER_PROFILE_SAMPLE_UPDATE
12100      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12101       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12102   /* Force the compiler not move sample-profiling instrumentation
12103      beyond this point; this way the actual user code is timed.
12104      This is still not perfect, as residuals are materialised before
12105      we arrive here, but should be adequate at least for slow VM
12106      instructions. */
12107   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12108 #endif
12109 #if defined (JITTER_PROFILE_COUNT)
12110   /* Notice that, differently from the code above, this
12111      instrumentation code *can* be reordered freely: as long as a
12112      VM instruction is counted, the count increment can be placed
12113      anyehere.  Let GCC move this code and possibly achieve better
12114      throughput by exploiting instruction-level parallelism and
12115      therefore approximate more closely a non-profiled build. */
12116   JITTER_PROFILE_COUNT_UPDATE
12117      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12118       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12119 #endif
12120 
12121 /* User-specified code, instruction-beginning-c part: beginning. */
12122 
12123 /* User-specified code, instruction-beginning-c part: end */
12124 
12125 
12126     /* User code for endhl . */
12127 #line 1868 "../../libpoke/pvm.jitter"
12128 
12129     if (!pk_term_end_hyperlink ())
12130       PVM_RAISE (PVM_E_GENERIC,
12131                  "no current hyperlink",
12132                  PVM_E_GENERIC_ESTATUS);
12133 
12134     /* End of the user code for endhl . */
12135 
12136 /* User-specified code, instruction-end-c part: beginning. */
12137 
12138 /* User-specified code, instruction-end-c part: end */
12139 
12140     /* Undefine the endhl argument macros so they can't be used
12141        by mistake in the instruction body coming next. */
12142 
12143 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12144 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12145 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12146 
12147   }
12148  JITTER_INSTRUCTION_EPILOG_(endhl, endhl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12149 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12150 
12151   JITTER_INSTRUCTION_PROLOG_(endsc, endsc, hot)
12152   {
12153     /* This specialized instruction is not a replacement. */
12154 #   undef JITTER_BRANCH_FAST
12155 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12156 #   undef JITTER_BRANCH_FAST_IF_ZERO
12157 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12158 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12159 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12160 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12161 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12162 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12163 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12164 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12165 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12166 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12167 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12168 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12169 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12170 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12171 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12172 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12173 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12174 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12175 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12176 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12177 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12178 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12179 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12180 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12181 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12182 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12183 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12184 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12185 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12186 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12187 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12188 #   undef JITTER_BRANCH_FAST_IF_AND
12189 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12190 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12191 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12192 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12193 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12194 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12195 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12196 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12197 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12198 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12199 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12200 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12201 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12202 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12203 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12204 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12205 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12206 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12207 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12208 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12209 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12210 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12211 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12212 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12213 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12214 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12215 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12216 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12217 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12218 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       73
12219 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         endsc
12220 
12221 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME endsc
12222 
12223   /* The residual arity for this instruction does not depend on fast labels. */
12224   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12225 
12226 
12227 #if defined (JITTER_PROFILE_SAMPLE)
12228   JITTER_PROFILE_SAMPLE_UPDATE
12229      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12230       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12231   /* Force the compiler not move sample-profiling instrumentation
12232      beyond this point; this way the actual user code is timed.
12233      This is still not perfect, as residuals are materialised before
12234      we arrive here, but should be adequate at least for slow VM
12235      instructions. */
12236   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12237 #endif
12238 #if defined (JITTER_PROFILE_COUNT)
12239   /* Notice that, differently from the code above, this
12240      instrumentation code *can* be reordered freely: as long as a
12241      VM instruction is counted, the count increment can be placed
12242      anyehere.  Let GCC move this code and possibly achieve better
12243      throughput by exploiting instruction-level parallelism and
12244      therefore approximate more closely a non-profiled build. */
12245   JITTER_PROFILE_COUNT_UPDATE
12246      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12247       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12248 #endif
12249 
12250 /* User-specified code, instruction-beginning-c part: beginning. */
12251 
12252 /* User-specified code, instruction-beginning-c part: end */
12253 
12254 
12255     /* User code for endsc . */
12256 #line 1899 "../../libpoke/pvm.jitter"
12257 
12258     if (!pk_term_end_class (PVM_VAL_STR (JITTER_TOP_STACK ())))
12259       PVM_RAISE (PVM_E_INVAL,
12260                  "invalid class",
12261                  PVM_E_INVAL_ESTATUS);
12262     JITTER_DROP_STACK ();
12263 
12264     /* End of the user code for endsc . */
12265 
12266 /* User-specified code, instruction-end-c part: beginning. */
12267 
12268 /* User-specified code, instruction-end-c part: end */
12269 
12270     /* Undefine the endsc argument macros so they can't be used
12271        by mistake in the instruction body coming next. */
12272 
12273 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12274 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12275 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12276 
12277   }
12278  JITTER_INSTRUCTION_EPILOG_(endsc, endsc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12279 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12280 
12281   JITTER_INSTRUCTION_PROLOG_(eqi, eqi, hot)
12282   {
12283     /* This specialized instruction is not a replacement. */
12284 #   undef JITTER_BRANCH_FAST
12285 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12286 #   undef JITTER_BRANCH_FAST_IF_ZERO
12287 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12288 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12289 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12290 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12291 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12292 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12293 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12294 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12295 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12296 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12297 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12298 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12299 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12300 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12301 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12302 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12303 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12304 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12305 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12306 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12307 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12308 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12309 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12310 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12311 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12312 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12313 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12314 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12315 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12316 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12317 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12318 #   undef JITTER_BRANCH_FAST_IF_AND
12319 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12320 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12321 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12322 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12323 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12324 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12325 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12326 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12327 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12328 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12329 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12330 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12331 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12332 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12333 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12334 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12335 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12336 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12337 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12338 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12339 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12340 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12341 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12342 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12343 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12344 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12345 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12346 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12347 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12348 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       74
12349 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         eqi
12350 
12351 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME eqi
12352 
12353   /* The residual arity for this instruction does not depend on fast labels. */
12354   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12355 
12356 
12357 #if defined (JITTER_PROFILE_SAMPLE)
12358   JITTER_PROFILE_SAMPLE_UPDATE
12359      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12360       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12361   /* Force the compiler not move sample-profiling instrumentation
12362      beyond this point; this way the actual user code is timed.
12363      This is still not perfect, as residuals are materialised before
12364      we arrive here, but should be adequate at least for slow VM
12365      instructions. */
12366   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12367 #endif
12368 #if defined (JITTER_PROFILE_COUNT)
12369   /* Notice that, differently from the code above, this
12370      instrumentation code *can* be reordered freely: as long as a
12371      VM instruction is counted, the count increment can be placed
12372      anyehere.  Let GCC move this code and possibly achieve better
12373      throughput by exploiting instruction-level parallelism and
12374      therefore approximate more closely a non-profiled build. */
12375   JITTER_PROFILE_COUNT_UPDATE
12376      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12377       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12378 #endif
12379 
12380 /* User-specified code, instruction-beginning-c part: beginning. */
12381 
12382 /* User-specified code, instruction-beginning-c part: end */
12383 
12384 
12385     /* User code for eqi . */
12386 #line 2681 "../../libpoke/pvm.jitter"
12387 
12388      PVM_BOOL_BINOP (INT, ==);
12389 
12390     /* End of the user code for eqi . */
12391 
12392 /* User-specified code, instruction-end-c part: beginning. */
12393 
12394 /* User-specified code, instruction-end-c part: end */
12395 
12396     /* Undefine the eqi argument macros so they can't be used
12397        by mistake in the instruction body coming next. */
12398 
12399 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12400 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12401 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12402 
12403   }
12404  JITTER_INSTRUCTION_EPILOG_(eqi, eqi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12405 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12406 
12407   JITTER_INSTRUCTION_PROLOG_(eqiu, eqiu, hot)
12408   {
12409     /* This specialized instruction is not a replacement. */
12410 #   undef JITTER_BRANCH_FAST
12411 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12412 #   undef JITTER_BRANCH_FAST_IF_ZERO
12413 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12414 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12415 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12416 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12417 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12418 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12419 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12420 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12421 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12422 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12423 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12424 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12425 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12426 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12427 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12428 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12429 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12430 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12431 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12432 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12433 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12434 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12435 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12436 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12437 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12438 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12439 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12440 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12441 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12442 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12443 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12444 #   undef JITTER_BRANCH_FAST_IF_AND
12445 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12446 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12447 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12448 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12449 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12450 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12451 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12452 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12453 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12454 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12455 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12456 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12457 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12458 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12459 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12460 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12461 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12462 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12463 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12464 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12465 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12466 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12467 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12468 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12469 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12470 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12471 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12472 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12473 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12474 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       75
12475 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         eqiu
12476 
12477 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME eqiu
12478 
12479   /* The residual arity for this instruction does not depend on fast labels. */
12480   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12481 
12482 
12483 #if defined (JITTER_PROFILE_SAMPLE)
12484   JITTER_PROFILE_SAMPLE_UPDATE
12485      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12486       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12487   /* Force the compiler not move sample-profiling instrumentation
12488      beyond this point; this way the actual user code is timed.
12489      This is still not perfect, as residuals are materialised before
12490      we arrive here, but should be adequate at least for slow VM
12491      instructions. */
12492   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12493 #endif
12494 #if defined (JITTER_PROFILE_COUNT)
12495   /* Notice that, differently from the code above, this
12496      instrumentation code *can* be reordered freely: as long as a
12497      VM instruction is counted, the count increment can be placed
12498      anyehere.  Let GCC move this code and possibly achieve better
12499      throughput by exploiting instruction-level parallelism and
12500      therefore approximate more closely a non-profiled build. */
12501   JITTER_PROFILE_COUNT_UPDATE
12502      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12503       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12504 #endif
12505 
12506 /* User-specified code, instruction-beginning-c part: beginning. */
12507 
12508 /* User-specified code, instruction-beginning-c part: end */
12509 
12510 
12511     /* User code for eqiu . */
12512 #line 2694 "../../libpoke/pvm.jitter"
12513 
12514      PVM_BOOL_BINOP (UINT, ==);
12515 
12516     /* End of the user code for eqiu . */
12517 
12518 /* User-specified code, instruction-end-c part: beginning. */
12519 
12520 /* User-specified code, instruction-end-c part: end */
12521 
12522     /* Undefine the eqiu argument macros so they can't be used
12523        by mistake in the instruction body coming next. */
12524 
12525 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12526 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12527 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12528 
12529   }
12530  JITTER_INSTRUCTION_EPILOG_(eqiu, eqiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12531 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12532 
12533   JITTER_INSTRUCTION_PROLOG_(eql, eql, hot)
12534   {
12535     /* This specialized instruction is not a replacement. */
12536 #   undef JITTER_BRANCH_FAST
12537 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12538 #   undef JITTER_BRANCH_FAST_IF_ZERO
12539 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12540 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12541 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12542 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12543 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12544 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12545 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12546 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12547 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12548 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12549 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12550 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12551 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12552 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12553 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12554 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12555 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12556 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12557 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12558 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12559 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12560 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12561 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12562 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12563 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12564 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12565 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12566 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12567 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12568 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12569 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12570 #   undef JITTER_BRANCH_FAST_IF_AND
12571 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12572 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12573 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12574 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12575 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12576 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12577 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12578 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12579 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12580 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12581 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12582 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12583 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12584 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12585 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12586 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12587 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12588 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12589 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12590 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12591 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12592 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12593 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12594 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12595 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12596 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12597 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12598 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12599 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12600 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       76
12601 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         eql
12602 
12603 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME eql
12604 
12605   /* The residual arity for this instruction does not depend on fast labels. */
12606   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12607 
12608 
12609 #if defined (JITTER_PROFILE_SAMPLE)
12610   JITTER_PROFILE_SAMPLE_UPDATE
12611      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12612       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12613   /* Force the compiler not move sample-profiling instrumentation
12614      beyond this point; this way the actual user code is timed.
12615      This is still not perfect, as residuals are materialised before
12616      we arrive here, but should be adequate at least for slow VM
12617      instructions. */
12618   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12619 #endif
12620 #if defined (JITTER_PROFILE_COUNT)
12621   /* Notice that, differently from the code above, this
12622      instrumentation code *can* be reordered freely: as long as a
12623      VM instruction is counted, the count increment can be placed
12624      anyehere.  Let GCC move this code and possibly achieve better
12625      throughput by exploiting instruction-level parallelism and
12626      therefore approximate more closely a non-profiled build. */
12627   JITTER_PROFILE_COUNT_UPDATE
12628      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12629       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12630 #endif
12631 
12632 /* User-specified code, instruction-beginning-c part: beginning. */
12633 
12634 /* User-specified code, instruction-beginning-c part: end */
12635 
12636 
12637     /* User code for eql . */
12638 #line 2707 "../../libpoke/pvm.jitter"
12639 
12640      PVM_BOOL_BINOP (LONG, ==);
12641 
12642     /* End of the user code for eql . */
12643 
12644 /* User-specified code, instruction-end-c part: beginning. */
12645 
12646 /* User-specified code, instruction-end-c part: end */
12647 
12648     /* Undefine the eql argument macros so they can't be used
12649        by mistake in the instruction body coming next. */
12650 
12651 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12652 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12653 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12654 
12655   }
12656  JITTER_INSTRUCTION_EPILOG_(eql, eql, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12657 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12658 
12659   JITTER_INSTRUCTION_PROLOG_(eqlu, eqlu, hot)
12660   {
12661     /* This specialized instruction is not a replacement. */
12662 #   undef JITTER_BRANCH_FAST
12663 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12664 #   undef JITTER_BRANCH_FAST_IF_ZERO
12665 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12666 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12667 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12668 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12669 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12670 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12671 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12672 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12673 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12674 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12675 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12676 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12677 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12678 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12679 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12680 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12681 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12682 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12683 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12684 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12685 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12686 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12687 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12688 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12689 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12690 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12691 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12692 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12693 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12694 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12695 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12696 #   undef JITTER_BRANCH_FAST_IF_AND
12697 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12698 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12699 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12700 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12701 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12702 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12703 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12704 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12705 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12706 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12707 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12708 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12709 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12710 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12711 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12712 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12713 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12714 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12715 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12716 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12717 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12718 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12719 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12720 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12721 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12722 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12723 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12724 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12725 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12726 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       77
12727 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         eqlu
12728 
12729 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME eqlu
12730 
12731   /* The residual arity for this instruction does not depend on fast labels. */
12732   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12733 
12734 
12735 #if defined (JITTER_PROFILE_SAMPLE)
12736   JITTER_PROFILE_SAMPLE_UPDATE
12737      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12738       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12739   /* Force the compiler not move sample-profiling instrumentation
12740      beyond this point; this way the actual user code is timed.
12741      This is still not perfect, as residuals are materialised before
12742      we arrive here, but should be adequate at least for slow VM
12743      instructions. */
12744   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12745 #endif
12746 #if defined (JITTER_PROFILE_COUNT)
12747   /* Notice that, differently from the code above, this
12748      instrumentation code *can* be reordered freely: as long as a
12749      VM instruction is counted, the count increment can be placed
12750      anyehere.  Let GCC move this code and possibly achieve better
12751      throughput by exploiting instruction-level parallelism and
12752      therefore approximate more closely a non-profiled build. */
12753   JITTER_PROFILE_COUNT_UPDATE
12754      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12755       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12756 #endif
12757 
12758 /* User-specified code, instruction-beginning-c part: beginning. */
12759 
12760 /* User-specified code, instruction-beginning-c part: end */
12761 
12762 
12763     /* User code for eqlu . */
12764 #line 2720 "../../libpoke/pvm.jitter"
12765 
12766      PVM_BOOL_BINOP (ULONG, ==);
12767 
12768     /* End of the user code for eqlu . */
12769 
12770 /* User-specified code, instruction-end-c part: beginning. */
12771 
12772 /* User-specified code, instruction-end-c part: end */
12773 
12774     /* Undefine the eqlu argument macros so they can't be used
12775        by mistake in the instruction body coming next. */
12776 
12777 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12778 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12779 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12780 
12781   }
12782  JITTER_INSTRUCTION_EPILOG_(eqlu, eqlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12783 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12784 
12785   JITTER_INSTRUCTION_PROLOG_(eqs, eqs, hot)
12786   {
12787     /* This specialized instruction is not a replacement. */
12788 #   undef JITTER_BRANCH_FAST
12789 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12790 #   undef JITTER_BRANCH_FAST_IF_ZERO
12791 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12792 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12793 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12794 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12795 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12796 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12797 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12798 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12799 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12800 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12801 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12802 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12803 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12804 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12805 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12806 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12807 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12808 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12809 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12810 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12811 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12812 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12813 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12814 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12815 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12816 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12817 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12818 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12819 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12820 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12821 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12822 #   undef JITTER_BRANCH_FAST_IF_AND
12823 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12824 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12825 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12826 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12827 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12828 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12829 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12830 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12831 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12832 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12833 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12834 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12835 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12836 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12837 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12838 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12839 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12840 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12841 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12842 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12843 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12844 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12845 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12846 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12847 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12848 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12849 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12850 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12851 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12852 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       78
12853 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         eqs
12854 
12855 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME eqs
12856 
12857   /* The residual arity for this instruction does not depend on fast labels. */
12858   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12859 
12860 
12861 #if defined (JITTER_PROFILE_SAMPLE)
12862   JITTER_PROFILE_SAMPLE_UPDATE
12863      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12864       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12865   /* Force the compiler not move sample-profiling instrumentation
12866      beyond this point; this way the actual user code is timed.
12867      This is still not perfect, as residuals are materialised before
12868      we arrive here, but should be adequate at least for slow VM
12869      instructions. */
12870   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12871 #endif
12872 #if defined (JITTER_PROFILE_COUNT)
12873   /* Notice that, differently from the code above, this
12874      instrumentation code *can* be reordered freely: as long as a
12875      VM instruction is counted, the count increment can be placed
12876      anyehere.  Let GCC move this code and possibly achieve better
12877      throughput by exploiting instruction-level parallelism and
12878      therefore approximate more closely a non-profiled build. */
12879   JITTER_PROFILE_COUNT_UPDATE
12880      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12881       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12882 #endif
12883 
12884 /* User-specified code, instruction-beginning-c part: beginning. */
12885 
12886 /* User-specified code, instruction-beginning-c part: end */
12887 
12888 
12889     /* User code for eqs . */
12890 #line 2733 "../../libpoke/pvm.jitter"
12891 
12892     pvm_val res = PVM_MAKE_INT (STREQ (PVM_VAL_STR (JITTER_UNDER_TOP_STACK ()),
12893                                        PVM_VAL_STR (JITTER_TOP_STACK ())),
12894                                 32);
12895     JITTER_PUSH_STACK (res);
12896 
12897     /* End of the user code for eqs . */
12898 
12899 /* User-specified code, instruction-end-c part: beginning. */
12900 
12901 /* User-specified code, instruction-end-c part: end */
12902 
12903     /* Undefine the eqs argument macros so they can't be used
12904        by mistake in the instruction body coming next. */
12905 
12906 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12907 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12908 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12909 
12910   }
12911  JITTER_INSTRUCTION_EPILOG_(eqs, eqs, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12912 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12913 
12914   JITTER_INSTRUCTION_PROLOG_(exit, exit, hot)
12915   {
12916     /* This specialized instruction is not a replacement. */
12917 #   undef JITTER_BRANCH_FAST
12918 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12919 #   undef JITTER_BRANCH_FAST_IF_ZERO
12920 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12921 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12922 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12923 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12924 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12925 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12926 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12927 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12928 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12929 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12930 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12931 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12932 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12933 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12934 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12935 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12936 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12937 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12938 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12939 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12940 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12941 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12942 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12943 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12944 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12945 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12946 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12947 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12948 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12949 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12950 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12951 #   undef JITTER_BRANCH_FAST_IF_AND
12952 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12953 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12954 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12955 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12956 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12957 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12958 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12959 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12960 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12961 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12962 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12963 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12964 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12965 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12966 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12967 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12968 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12969 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12970 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12971 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12972 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12973 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12974 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12975 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12976 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12977 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12978 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12979 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12980 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12981 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       79
12982 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         exit
12983 
12984 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME exit
12985 
12986   /* The residual arity for this instruction does not depend on fast labels. */
12987   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12988 
12989 
12990 #if defined (JITTER_PROFILE_SAMPLE)
12991   JITTER_PROFILE_SAMPLE_UPDATE
12992      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12993       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12994   /* Force the compiler not move sample-profiling instrumentation
12995      beyond this point; this way the actual user code is timed.
12996      This is still not perfect, as residuals are materialised before
12997      we arrive here, but should be adequate at least for slow VM
12998      instructions. */
12999   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13000 #endif
13001 #if defined (JITTER_PROFILE_COUNT)
13002   /* Notice that, differently from the code above, this
13003      instrumentation code *can* be reordered freely: as long as a
13004      VM instruction is counted, the count increment can be placed
13005      anyehere.  Let GCC move this code and possibly achieve better
13006      throughput by exploiting instruction-level parallelism and
13007      therefore approximate more closely a non-profiled build. */
13008   JITTER_PROFILE_COUNT_UPDATE
13009      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13010       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13011 #endif
13012 
13013 /* User-specified code, instruction-beginning-c part: beginning. */
13014 
13015 /* User-specified code, instruction-beginning-c part: end */
13016 
13017 
13018     /* User code for exit . */
13019 #line 890 "../../libpoke/pvm.jitter"
13020 
13021     /* The element at the top of the stack is the exit
13022        code to report to the PVM caller.  */
13023     JITTER_STATE_BACKING_FIELD (exit_code)
13024       = PVM_VAL_INT (JITTER_TOP_STACK());
13025 
13026     JITTER_DROP_STACK ();
13027 
13028     /* Get the result of the execution, if any.  */
13029     JITTER_STATE_BACKING_FIELD (result_value)
13030                 = JITTER_TOP_STACK();
13031     JITTER_DROP_STACK ();
13032 
13033     /* Check for the stack centinel, but only if it was
13034        installed.  */
13035     if (JITTER_STATE_BACKING_FIELD (canary) != NULL)
13036       assert (JITTER_STATE_BACKING_FIELD (canary)
13037               == JITTER_HEIGHT_STACK ());
13038 
13039     /* Clear pending signals.  */
13040     {
13041       int i;
13042       for (i = 0; i < JITTER_SIGNAL_NO; i ++)
13043         if (JITTER_PENDING_SIGNAL_NOTIFICATION (i))
13044           JITTER_PENDING_SIGNAL_NOTIFICATION (i) = false;
13045       JITTER_PENDING_NOTIFICATIONS = false;
13046     }
13047 
13048     JITTER_EXIT ();
13049 
13050     /* End of the user code for exit . */
13051 
13052 /* User-specified code, instruction-end-c part: beginning. */
13053 
13054 /* User-specified code, instruction-end-c part: end */
13055 
13056     /* Undefine the exit argument macros so they can't be used
13057        by mistake in the instruction body coming next. */
13058 
13059 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13060 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13061 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13062 
13063   }
13064  JITTER_INSTRUCTION_EPILOG_(exit, exit, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13065 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13066 
13067   JITTER_INSTRUCTION_PROLOG_(exitvm, exitvm, cold)
13068   {
13069     /* This specialized instruction is not a replacement. */
13070 #   undef JITTER_BRANCH_FAST
13071 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13072 #   undef JITTER_BRANCH_FAST_IF_ZERO
13073 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13074 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13075 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13076 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13077 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13078 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13079 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13080 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13081 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13082 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13083 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13084 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13085 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13086 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13087 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13088 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13089 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13090 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13091 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13092 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13093 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13094 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13095 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13096 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13097 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13098 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13099 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13100 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13101 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13102 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13103 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13104 #   undef JITTER_BRANCH_FAST_IF_AND
13105 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13106 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13107 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13108 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13109 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13110 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13111 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13112 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13113 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13114 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13115 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13116 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13117 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13118 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13119 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13120 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13121 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13122 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13123 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13124 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13125 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13126 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13127 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13128 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13129 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13130 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13131 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13132 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13133 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13134 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       80
13135 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         exitvm
13136 
13137 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME exitvm
13138 
13139   /* The residual arity for this instruction does not depend on fast labels. */
13140   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13141 
13142 
13143 #if defined (JITTER_PROFILE_SAMPLE)
13144   JITTER_PROFILE_SAMPLE_UPDATE
13145      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13146       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13147   /* Force the compiler not move sample-profiling instrumentation
13148      beyond this point; this way the actual user code is timed.
13149      This is still not perfect, as residuals are materialised before
13150      we arrive here, but should be adequate at least for slow VM
13151      instructions. */
13152   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13153 #endif
13154 #if defined (JITTER_PROFILE_COUNT)
13155   /* Notice that, differently from the code above, this
13156      instrumentation code *can* be reordered freely: as long as a
13157      VM instruction is counted, the count increment can be placed
13158      anyehere.  Let GCC move this code and possibly achieve better
13159      throughput by exploiting instruction-level parallelism and
13160      therefore approximate more closely a non-profiled build. */
13161   JITTER_PROFILE_COUNT_UPDATE
13162      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13163       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13164 #endif
13165 
13166 /* User-specified code, instruction-beginning-c part: beginning. */
13167 
13168 /* User-specified code, instruction-beginning-c part: end */
13169 
13170 
13171     /* User code for exitvm . */
13172 JITTER_EXIT();
13173     /* End of the user code for exitvm . */
13174 
13175 /* User-specified code, instruction-end-c part: beginning. */
13176 
13177 /* User-specified code, instruction-end-c part: end */
13178 
13179     /* Undefine the exitvm argument macros so they can't be used
13180        by mistake in the instruction body coming next. */
13181 
13182 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13183 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13184 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13185 
13186   }
13187  JITTER_INSTRUCTION_EPILOG_(exitvm, exitvm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13188 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13189 
13190   JITTER_INSTRUCTION_PROLOG_(flush, flush, hot)
13191   {
13192     /* This specialized instruction is not a replacement. */
13193 #   undef JITTER_BRANCH_FAST
13194 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13195 #   undef JITTER_BRANCH_FAST_IF_ZERO
13196 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13197 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13198 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13199 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13200 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13201 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13202 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13203 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13204 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13205 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13206 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13207 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13208 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13209 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13210 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13211 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13212 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13213 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13214 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13215 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13216 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13217 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13218 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13219 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13220 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13221 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13222 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13223 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13224 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13225 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13226 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13227 #   undef JITTER_BRANCH_FAST_IF_AND
13228 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13229 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13230 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13231 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13232 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13233 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13234 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13235 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13236 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13237 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13238 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13239 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13240 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13241 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13242 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13243 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13244 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13245 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13246 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13247 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13248 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13249 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13250 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13251 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13252 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13253 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13254 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13255 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13256 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13257 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       81
13258 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         flush
13259 
13260 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME flush
13261 
13262   /* The residual arity for this instruction does not depend on fast labels. */
13263   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13264 
13265 
13266 #if defined (JITTER_PROFILE_SAMPLE)
13267   JITTER_PROFILE_SAMPLE_UPDATE
13268      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13269       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13270   /* Force the compiler not move sample-profiling instrumentation
13271      beyond this point; this way the actual user code is timed.
13272      This is still not perfect, as residuals are materialised before
13273      we arrive here, but should be adequate at least for slow VM
13274      instructions. */
13275   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13276 #endif
13277 #if defined (JITTER_PROFILE_COUNT)
13278   /* Notice that, differently from the code above, this
13279      instrumentation code *can* be reordered freely: as long as a
13280      VM instruction is counted, the count increment can be placed
13281      anyehere.  Let GCC move this code and possibly achieve better
13282      throughput by exploiting instruction-level parallelism and
13283      therefore approximate more closely a non-profiled build. */
13284   JITTER_PROFILE_COUNT_UPDATE
13285      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13286       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13287 #endif
13288 
13289 /* User-specified code, instruction-beginning-c part: beginning. */
13290 
13291 /* User-specified code, instruction-beginning-c part: end */
13292 
13293 
13294     /* User code for flush . */
13295 #line 1407 "../../libpoke/pvm.jitter"
13296 
13297     ios_off offset = PVM_VAL_ULONG (JITTER_TOP_STACK ());
13298     int io_id = PVM_VAL_INT (JITTER_UNDER_TOP_STACK ());
13299     ios io = ios_search_by_id (io_id);
13300 
13301     if (io == NULL)
13302       PVM_RAISE_DFL (PVM_E_IO);
13303 
13304     if (ios_flush (io, offset) != IOS_OK)
13305       PVM_RAISE_DFL (PVM_E_IO);
13306 
13307     JITTER_DROP_STACK ();
13308     JITTER_DROP_STACK ();
13309 
13310     /* End of the user code for flush . */
13311 
13312 /* User-specified code, instruction-end-c part: beginning. */
13313 
13314 /* User-specified code, instruction-end-c part: end */
13315 
13316     /* Undefine the flush argument macros so they can't be used
13317        by mistake in the instruction body coming next. */
13318 
13319 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13320 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13321 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13322 
13323   }
13324  JITTER_INSTRUCTION_EPILOG_(flush, flush, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13325 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13326 
13327   JITTER_INSTRUCTION_PROLOG_(fromr, fromr, hot)
13328   {
13329     /* This specialized instruction is not a replacement. */
13330 #   undef JITTER_BRANCH_FAST
13331 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13332 #   undef JITTER_BRANCH_FAST_IF_ZERO
13333 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13334 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13335 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13336 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13337 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13338 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13339 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13340 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13341 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13342 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13343 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13344 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13345 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13346 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13347 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13348 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13349 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13350 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13351 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13352 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13353 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13354 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13355 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13356 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13357 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13358 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13359 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13360 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13361 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13362 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13363 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13364 #   undef JITTER_BRANCH_FAST_IF_AND
13365 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13366 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13367 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13368 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13369 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13370 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13371 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13372 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13373 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13374 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13375 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13376 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13377 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13378 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13379 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13380 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13381 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13382 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13383 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13384 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13385 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13386 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13387 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13388 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13389 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13390 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13391 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13392 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13393 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13394 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       82
13395 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         fromr
13396 
13397 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME fromr
13398 
13399   /* The residual arity for this instruction does not depend on fast labels. */
13400   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13401 
13402 
13403 #if defined (JITTER_PROFILE_SAMPLE)
13404   JITTER_PROFILE_SAMPLE_UPDATE
13405      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13406       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13407   /* Force the compiler not move sample-profiling instrumentation
13408      beyond this point; this way the actual user code is timed.
13409      This is still not perfect, as residuals are materialised before
13410      we arrive here, but should be adequate at least for slow VM
13411      instructions. */
13412   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13413 #endif
13414 #if defined (JITTER_PROFILE_COUNT)
13415   /* Notice that, differently from the code above, this
13416      instrumentation code *can* be reordered freely: as long as a
13417      VM instruction is counted, the count increment can be placed
13418      anyehere.  Let GCC move this code and possibly achieve better
13419      throughput by exploiting instruction-level parallelism and
13420      therefore approximate more closely a non-profiled build. */
13421   JITTER_PROFILE_COUNT_UPDATE
13422      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13423       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13424 #endif
13425 
13426 /* User-specified code, instruction-beginning-c part: beginning. */
13427 
13428 /* User-specified code, instruction-beginning-c part: end */
13429 
13430 
13431     /* User code for fromr . */
13432 #line 2263 "../../libpoke/pvm.jitter"
13433 
13434     JITTER_PUSH_STACK (JITTER_TOP_RETURNSTACK ());
13435     JITTER_DROP_RETURNSTACK ();
13436 
13437     /* End of the user code for fromr . */
13438 
13439 /* User-specified code, instruction-end-c part: beginning. */
13440 
13441 /* User-specified code, instruction-end-c part: end */
13442 
13443     /* Undefine the fromr argument macros so they can't be used
13444        by mistake in the instruction body coming next. */
13445 
13446 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13447 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13448 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13449 
13450   }
13451  JITTER_INSTRUCTION_EPILOG_(fromr, fromr, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13452 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13453 
13454   JITTER_INSTRUCTION_PROLOG_(gei, gei, hot)
13455   {
13456     /* This specialized instruction is not a replacement. */
13457 #   undef JITTER_BRANCH_FAST
13458 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13459 #   undef JITTER_BRANCH_FAST_IF_ZERO
13460 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13461 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13462 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13463 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13464 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13465 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13466 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13467 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13468 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13469 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13470 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13471 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13472 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13473 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13474 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13475 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13476 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13477 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13478 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13479 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13480 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13481 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13482 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13483 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13484 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13485 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13486 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13487 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13488 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13489 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13490 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13491 #   undef JITTER_BRANCH_FAST_IF_AND
13492 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13493 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13494 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13495 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13496 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13497 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13498 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13499 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13500 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13501 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13502 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13503 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13504 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13505 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13506 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13507 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13508 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13509 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13510 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13511 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13512 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13513 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13514 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13515 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13516 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13517 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13518 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13519 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13520 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13521 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       83
13522 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gei
13523 
13524 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gei
13525 
13526   /* The residual arity for this instruction does not depend on fast labels. */
13527   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13528 
13529 
13530 #if defined (JITTER_PROFILE_SAMPLE)
13531   JITTER_PROFILE_SAMPLE_UPDATE
13532      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13533       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13534   /* Force the compiler not move sample-profiling instrumentation
13535      beyond this point; this way the actual user code is timed.
13536      This is still not perfect, as residuals are materialised before
13537      we arrive here, but should be adequate at least for slow VM
13538      instructions. */
13539   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13540 #endif
13541 #if defined (JITTER_PROFILE_COUNT)
13542   /* Notice that, differently from the code above, this
13543      instrumentation code *can* be reordered freely: as long as a
13544      VM instruction is counted, the count increment can be placed
13545      anyehere.  Let GCC move this code and possibly achieve better
13546      throughput by exploiting instruction-level parallelism and
13547      therefore approximate more closely a non-profiled build. */
13548   JITTER_PROFILE_COUNT_UPDATE
13549      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13550       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13551 #endif
13552 
13553 /* User-specified code, instruction-beginning-c part: beginning. */
13554 
13555 /* User-specified code, instruction-beginning-c part: end */
13556 
13557 
13558     /* User code for gei . */
13559 #line 3001 "../../libpoke/pvm.jitter"
13560 
13561      PVM_BOOL_BINOP (INT, >=);
13562 
13563     /* End of the user code for gei . */
13564 
13565 /* User-specified code, instruction-end-c part: beginning. */
13566 
13567 /* User-specified code, instruction-end-c part: end */
13568 
13569     /* Undefine the gei argument macros so they can't be used
13570        by mistake in the instruction body coming next. */
13571 
13572 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13573 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13574 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13575 
13576   }
13577  JITTER_INSTRUCTION_EPILOG_(gei, gei, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13578 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13579 
13580   JITTER_INSTRUCTION_PROLOG_(geiu, geiu, hot)
13581   {
13582     /* This specialized instruction is not a replacement. */
13583 #   undef JITTER_BRANCH_FAST
13584 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13585 #   undef JITTER_BRANCH_FAST_IF_ZERO
13586 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13587 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13588 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13589 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13590 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13591 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13592 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13593 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13594 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13595 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13596 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13597 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13598 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13599 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13600 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13601 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13602 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13603 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13604 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13605 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13606 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13607 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13608 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13609 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13610 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13611 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13612 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13613 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13614 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13615 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13616 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13617 #   undef JITTER_BRANCH_FAST_IF_AND
13618 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13619 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13620 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13621 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13622 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13623 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13624 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13625 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13626 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13627 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13628 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13629 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13630 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13631 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13632 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13633 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13634 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13635 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13636 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13637 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13638 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13639 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13640 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13641 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13642 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13643 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13644 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13645 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13646 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13647 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       84
13648 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         geiu
13649 
13650 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME geiu
13651 
13652   /* The residual arity for this instruction does not depend on fast labels. */
13653   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13654 
13655 
13656 #if defined (JITTER_PROFILE_SAMPLE)
13657   JITTER_PROFILE_SAMPLE_UPDATE
13658      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13659       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13660   /* Force the compiler not move sample-profiling instrumentation
13661      beyond this point; this way the actual user code is timed.
13662      This is still not perfect, as residuals are materialised before
13663      we arrive here, but should be adequate at least for slow VM
13664      instructions. */
13665   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13666 #endif
13667 #if defined (JITTER_PROFILE_COUNT)
13668   /* Notice that, differently from the code above, this
13669      instrumentation code *can* be reordered freely: as long as a
13670      VM instruction is counted, the count increment can be placed
13671      anyehere.  Let GCC move this code and possibly achieve better
13672      throughput by exploiting instruction-level parallelism and
13673      therefore approximate more closely a non-profiled build. */
13674   JITTER_PROFILE_COUNT_UPDATE
13675      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13676       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13677 #endif
13678 
13679 /* User-specified code, instruction-beginning-c part: beginning. */
13680 
13681 /* User-specified code, instruction-beginning-c part: end */
13682 
13683 
13684     /* User code for geiu . */
13685 #line 3015 "../../libpoke/pvm.jitter"
13686 
13687      PVM_BOOL_BINOP (UINT, >=);
13688 
13689     /* End of the user code for geiu . */
13690 
13691 /* User-specified code, instruction-end-c part: beginning. */
13692 
13693 /* User-specified code, instruction-end-c part: end */
13694 
13695     /* Undefine the geiu argument macros so they can't be used
13696        by mistake in the instruction body coming next. */
13697 
13698 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13699 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13700 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13701 
13702   }
13703  JITTER_INSTRUCTION_EPILOG_(geiu, geiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13704 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13705 
13706   JITTER_INSTRUCTION_PROLOG_(gel, gel, hot)
13707   {
13708     /* This specialized instruction is not a replacement. */
13709 #   undef JITTER_BRANCH_FAST
13710 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13711 #   undef JITTER_BRANCH_FAST_IF_ZERO
13712 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13713 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13714 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13715 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13716 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13717 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13718 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13719 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13720 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13721 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13722 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13723 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13724 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13725 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13726 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13727 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13728 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13729 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13730 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13731 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13732 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13733 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13734 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13735 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13736 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13737 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13738 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13739 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13740 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13741 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13742 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13743 #   undef JITTER_BRANCH_FAST_IF_AND
13744 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13745 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13746 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13747 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13748 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13749 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13750 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13751 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13752 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13753 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13754 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13755 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13756 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13757 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13758 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13759 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13760 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13761 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13762 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13763 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13764 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13765 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13766 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13767 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13768 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13769 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13770 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13771 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13772 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13773 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       85
13774 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gel
13775 
13776 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gel
13777 
13778   /* The residual arity for this instruction does not depend on fast labels. */
13779   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13780 
13781 
13782 #if defined (JITTER_PROFILE_SAMPLE)
13783   JITTER_PROFILE_SAMPLE_UPDATE
13784      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13785       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13786   /* Force the compiler not move sample-profiling instrumentation
13787      beyond this point; this way the actual user code is timed.
13788      This is still not perfect, as residuals are materialised before
13789      we arrive here, but should be adequate at least for slow VM
13790      instructions. */
13791   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13792 #endif
13793 #if defined (JITTER_PROFILE_COUNT)
13794   /* Notice that, differently from the code above, this
13795      instrumentation code *can* be reordered freely: as long as a
13796      VM instruction is counted, the count increment can be placed
13797      anyehere.  Let GCC move this code and possibly achieve better
13798      throughput by exploiting instruction-level parallelism and
13799      therefore approximate more closely a non-profiled build. */
13800   JITTER_PROFILE_COUNT_UPDATE
13801      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13802       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13803 #endif
13804 
13805 /* User-specified code, instruction-beginning-c part: beginning. */
13806 
13807 /* User-specified code, instruction-beginning-c part: end */
13808 
13809 
13810     /* User code for gel . */
13811 #line 3028 "../../libpoke/pvm.jitter"
13812 
13813      PVM_BOOL_BINOP (LONG, >=);
13814 
13815     /* End of the user code for gel . */
13816 
13817 /* User-specified code, instruction-end-c part: beginning. */
13818 
13819 /* User-specified code, instruction-end-c part: end */
13820 
13821     /* Undefine the gel argument macros so they can't be used
13822        by mistake in the instruction body coming next. */
13823 
13824 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13825 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13826 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13827 
13828   }
13829  JITTER_INSTRUCTION_EPILOG_(gel, gel, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13830 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13831 
13832   JITTER_INSTRUCTION_PROLOG_(gelu, gelu, hot)
13833   {
13834     /* This specialized instruction is not a replacement. */
13835 #   undef JITTER_BRANCH_FAST
13836 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13837 #   undef JITTER_BRANCH_FAST_IF_ZERO
13838 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13839 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13840 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13841 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13842 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13843 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13844 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13845 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13846 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13847 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13848 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13849 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13850 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13851 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13852 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13853 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13854 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13855 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13856 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13857 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13858 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13859 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13860 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13861 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13862 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13863 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13864 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13865 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13866 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13867 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13868 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13869 #   undef JITTER_BRANCH_FAST_IF_AND
13870 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13871 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13872 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13873 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13874 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13875 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13876 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13877 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13878 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13879 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13880 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13881 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13882 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13883 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13884 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13885 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13886 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13887 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13888 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13889 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13890 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13891 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13892 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13893 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13894 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13895 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13896 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13897 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13898 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13899 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       86
13900 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gelu
13901 
13902 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gelu
13903 
13904   /* The residual arity for this instruction does not depend on fast labels. */
13905   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13906 
13907 
13908 #if defined (JITTER_PROFILE_SAMPLE)
13909   JITTER_PROFILE_SAMPLE_UPDATE
13910      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13911       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13912   /* Force the compiler not move sample-profiling instrumentation
13913      beyond this point; this way the actual user code is timed.
13914      This is still not perfect, as residuals are materialised before
13915      we arrive here, but should be adequate at least for slow VM
13916      instructions. */
13917   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13918 #endif
13919 #if defined (JITTER_PROFILE_COUNT)
13920   /* Notice that, differently from the code above, this
13921      instrumentation code *can* be reordered freely: as long as a
13922      VM instruction is counted, the count increment can be placed
13923      anyehere.  Let GCC move this code and possibly achieve better
13924      throughput by exploiting instruction-level parallelism and
13925      therefore approximate more closely a non-profiled build. */
13926   JITTER_PROFILE_COUNT_UPDATE
13927      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13928       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13929 #endif
13930 
13931 /* User-specified code, instruction-beginning-c part: beginning. */
13932 
13933 /* User-specified code, instruction-beginning-c part: end */
13934 
13935 
13936     /* User code for gelu . */
13937 #line 3041 "../../libpoke/pvm.jitter"
13938 
13939      PVM_BOOL_BINOP (ULONG, >=);
13940 
13941     /* End of the user code for gelu . */
13942 
13943 /* User-specified code, instruction-end-c part: beginning. */
13944 
13945 /* User-specified code, instruction-end-c part: end */
13946 
13947     /* Undefine the gelu argument macros so they can't be used
13948        by mistake in the instruction body coming next. */
13949 
13950 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13951 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13952 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13953 
13954   }
13955  JITTER_INSTRUCTION_EPILOG_(gelu, gelu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13956 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13957 
13958   JITTER_INSTRUCTION_PROLOG_(ges, ges, hot)
13959   {
13960     /* This specialized instruction is not a replacement. */
13961 #   undef JITTER_BRANCH_FAST
13962 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13963 #   undef JITTER_BRANCH_FAST_IF_ZERO
13964 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13965 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13966 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13967 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13968 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13969 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13970 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13971 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13972 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13973 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13974 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13975 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13976 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13977 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13978 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13979 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13980 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13981 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13982 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13983 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13984 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13985 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13986 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13987 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13988 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13989 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13990 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13991 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13992 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13993 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13994 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13995 #   undef JITTER_BRANCH_FAST_IF_AND
13996 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13997 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13998 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13999 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14000 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14001 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14002 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14003 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14004 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14005 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14006 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14007 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14008 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14009 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14010 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14011 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14012 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14013 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14014 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14015 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14016 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14017 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14018 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14019 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14020 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14021 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14022 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14023 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14024 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14025 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       87
14026 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ges
14027 
14028 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ges
14029 
14030   /* The residual arity for this instruction does not depend on fast labels. */
14031   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14032 
14033 
14034 #if defined (JITTER_PROFILE_SAMPLE)
14035   JITTER_PROFILE_SAMPLE_UPDATE
14036      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14037       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14038   /* Force the compiler not move sample-profiling instrumentation
14039      beyond this point; this way the actual user code is timed.
14040      This is still not perfect, as residuals are materialised before
14041      we arrive here, but should be adequate at least for slow VM
14042      instructions. */
14043   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14044 #endif
14045 #if defined (JITTER_PROFILE_COUNT)
14046   /* Notice that, differently from the code above, this
14047      instrumentation code *can* be reordered freely: as long as a
14048      VM instruction is counted, the count increment can be placed
14049      anyehere.  Let GCC move this code and possibly achieve better
14050      throughput by exploiting instruction-level parallelism and
14051      therefore approximate more closely a non-profiled build. */
14052   JITTER_PROFILE_COUNT_UPDATE
14053      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14054       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14055 #endif
14056 
14057 /* User-specified code, instruction-beginning-c part: beginning. */
14058 
14059 /* User-specified code, instruction-beginning-c part: end */
14060 
14061 
14062     /* User code for ges . */
14063 #line 3085 "../../libpoke/pvm.jitter"
14064 
14065     pvm_val res = PVM_MAKE_INT (strcmp (PVM_VAL_STR (JITTER_UNDER_TOP_STACK ()),
14066                                         PVM_VAL_STR (JITTER_TOP_STACK ())) >= 0, 32);
14067     JITTER_PUSH_STACK (res);
14068 
14069     /* End of the user code for ges . */
14070 
14071 /* User-specified code, instruction-end-c part: beginning. */
14072 
14073 /* User-specified code, instruction-end-c part: end */
14074 
14075     /* Undefine the ges argument macros so they can't be used
14076        by mistake in the instruction body coming next. */
14077 
14078 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14079 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14080 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14081 
14082   }
14083  JITTER_INSTRUCTION_EPILOG_(ges, ges, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14084 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14085 
14086   JITTER_INSTRUCTION_PROLOG_(getenv, getenv, hot)
14087   {
14088     /* This specialized instruction is not a replacement. */
14089 #   undef JITTER_BRANCH_FAST
14090 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14091 #   undef JITTER_BRANCH_FAST_IF_ZERO
14092 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14093 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14094 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14095 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14096 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14097 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14098 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14099 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14100 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14101 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14102 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14103 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14104 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14105 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14106 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14107 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14108 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14109 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14110 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14111 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14112 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14113 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14114 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14115 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14116 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14117 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14118 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14119 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14120 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14121 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14122 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14123 #   undef JITTER_BRANCH_FAST_IF_AND
14124 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14125 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14126 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14127 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14128 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14129 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14130 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14131 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14132 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14133 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14134 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14135 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14136 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14137 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14138 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14139 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14140 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14141 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14142 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14143 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14144 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14145 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14146 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14147 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14148 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14149 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14150 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14151 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14152 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14153 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       88
14154 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         getenv
14155 
14156 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME getenv
14157 
14158   /* The residual arity for this instruction does not depend on fast labels. */
14159   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14160 
14161 
14162 #if defined (JITTER_PROFILE_SAMPLE)
14163   JITTER_PROFILE_SAMPLE_UPDATE
14164      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14165       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14166   /* Force the compiler not move sample-profiling instrumentation
14167      beyond this point; this way the actual user code is timed.
14168      This is still not perfect, as residuals are materialised before
14169      we arrive here, but should be adequate at least for slow VM
14170      instructions. */
14171   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14172 #endif
14173 #if defined (JITTER_PROFILE_COUNT)
14174   /* Notice that, differently from the code above, this
14175      instrumentation code *can* be reordered freely: as long as a
14176      VM instruction is counted, the count increment can be placed
14177      anyehere.  Let GCC move this code and possibly achieve better
14178      throughput by exploiting instruction-level parallelism and
14179      therefore approximate more closely a non-profiled build. */
14180   JITTER_PROFILE_COUNT_UPDATE
14181      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14182       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14183 #endif
14184 
14185 /* User-specified code, instruction-beginning-c part: beginning. */
14186 
14187 /* User-specified code, instruction-beginning-c part: end */
14188 
14189 
14190     /* User code for getenv . */
14191 #line 5686 "../../libpoke/pvm.jitter"
14192 
14193     const char *varname = PVM_VAL_STR (JITTER_TOP_STACK ());
14194     char *value = secure_getenv (varname);
14195 
14196     if (value == NULL)
14197       JITTER_PUSH_STACK (PVM_NULL);
14198     else
14199       JITTER_PUSH_STACK (pvm_make_string (value));
14200 
14201     /* End of the user code for getenv . */
14202 
14203 /* User-specified code, instruction-end-c part: beginning. */
14204 
14205 /* User-specified code, instruction-end-c part: end */
14206 
14207     /* Undefine the getenv argument macros so they can't be used
14208        by mistake in the instruction body coming next. */
14209 
14210 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14211 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14212 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14213 
14214   }
14215  JITTER_INSTRUCTION_EPILOG_(getenv, getenv, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14216 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14217 
14218   JITTER_INSTRUCTION_PROLOG_(gti, gti, hot)
14219   {
14220     /* This specialized instruction is not a replacement. */
14221 #   undef JITTER_BRANCH_FAST
14222 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14223 #   undef JITTER_BRANCH_FAST_IF_ZERO
14224 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14225 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14226 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14227 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14228 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14229 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14230 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14231 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14232 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14233 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14234 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14235 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14236 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14237 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14238 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14239 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14240 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14241 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14242 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14243 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14244 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14245 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14246 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14247 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14248 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14249 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14250 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14251 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14252 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14253 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14254 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14255 #   undef JITTER_BRANCH_FAST_IF_AND
14256 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14257 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14258 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14259 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14260 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14261 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14262 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14263 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14264 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14265 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14266 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14267 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14268 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14269 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14270 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14271 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14272 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14273 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14274 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14275 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14276 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14277 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14278 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14279 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14280 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14281 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14282 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14283 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14284 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14285 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       89
14286 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gti
14287 
14288 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gti
14289 
14290   /* The residual arity for this instruction does not depend on fast labels. */
14291   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14292 
14293 
14294 #if defined (JITTER_PROFILE_SAMPLE)
14295   JITTER_PROFILE_SAMPLE_UPDATE
14296      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14297       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14298   /* Force the compiler not move sample-profiling instrumentation
14299      beyond this point; this way the actual user code is timed.
14300      This is still not perfect, as residuals are materialised before
14301      we arrive here, but should be adequate at least for slow VM
14302      instructions. */
14303   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14304 #endif
14305 #if defined (JITTER_PROFILE_COUNT)
14306   /* Notice that, differently from the code above, this
14307      instrumentation code *can* be reordered freely: as long as a
14308      VM instruction is counted, the count increment can be placed
14309      anyehere.  Let GCC move this code and possibly achieve better
14310      throughput by exploiting instruction-level parallelism and
14311      therefore approximate more closely a non-profiled build. */
14312   JITTER_PROFILE_COUNT_UPDATE
14313      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14314       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14315 #endif
14316 
14317 /* User-specified code, instruction-beginning-c part: beginning. */
14318 
14319 /* User-specified code, instruction-beginning-c part: end */
14320 
14321 
14322     /* User code for gti . */
14323 #line 2949 "../../libpoke/pvm.jitter"
14324 
14325      PVM_BOOL_BINOP (INT, >);
14326 
14327     /* End of the user code for gti . */
14328 
14329 /* User-specified code, instruction-end-c part: beginning. */
14330 
14331 /* User-specified code, instruction-end-c part: end */
14332 
14333     /* Undefine the gti argument macros so they can't be used
14334        by mistake in the instruction body coming next. */
14335 
14336 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14337 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14338 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14339 
14340   }
14341  JITTER_INSTRUCTION_EPILOG_(gti, gti, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14342 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14343 
14344   JITTER_INSTRUCTION_PROLOG_(gtiu, gtiu, hot)
14345   {
14346     /* This specialized instruction is not a replacement. */
14347 #   undef JITTER_BRANCH_FAST
14348 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14349 #   undef JITTER_BRANCH_FAST_IF_ZERO
14350 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14351 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14352 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14353 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14354 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14355 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14356 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14357 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14358 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14359 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14360 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14361 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14362 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14363 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14364 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14365 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14366 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14367 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14368 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14369 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14370 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14371 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14372 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14373 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14374 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14375 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14376 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14377 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14378 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14379 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14380 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14381 #   undef JITTER_BRANCH_FAST_IF_AND
14382 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14383 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14384 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14385 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14386 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14387 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14388 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14389 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14390 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14391 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14392 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14393 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14394 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14395 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14396 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14397 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14398 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14399 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14400 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14401 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14402 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14403 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14404 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14405 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14406 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14407 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14408 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14409 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14410 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14411 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       90
14412 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gtiu
14413 
14414 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gtiu
14415 
14416   /* The residual arity for this instruction does not depend on fast labels. */
14417   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14418 
14419 
14420 #if defined (JITTER_PROFILE_SAMPLE)
14421   JITTER_PROFILE_SAMPLE_UPDATE
14422      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14423       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14424   /* Force the compiler not move sample-profiling instrumentation
14425      beyond this point; this way the actual user code is timed.
14426      This is still not perfect, as residuals are materialised before
14427      we arrive here, but should be adequate at least for slow VM
14428      instructions. */
14429   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14430 #endif
14431 #if defined (JITTER_PROFILE_COUNT)
14432   /* Notice that, differently from the code above, this
14433      instrumentation code *can* be reordered freely: as long as a
14434      VM instruction is counted, the count increment can be placed
14435      anyehere.  Let GCC move this code and possibly achieve better
14436      throughput by exploiting instruction-level parallelism and
14437      therefore approximate more closely a non-profiled build. */
14438   JITTER_PROFILE_COUNT_UPDATE
14439      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14440       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14441 #endif
14442 
14443 /* User-specified code, instruction-beginning-c part: beginning. */
14444 
14445 /* User-specified code, instruction-beginning-c part: end */
14446 
14447 
14448     /* User code for gtiu . */
14449 #line 2962 "../../libpoke/pvm.jitter"
14450 
14451      PVM_BOOL_BINOP (UINT, >);
14452 
14453     /* End of the user code for gtiu . */
14454 
14455 /* User-specified code, instruction-end-c part: beginning. */
14456 
14457 /* User-specified code, instruction-end-c part: end */
14458 
14459     /* Undefine the gtiu argument macros so they can't be used
14460        by mistake in the instruction body coming next. */
14461 
14462 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14463 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14464 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14465 
14466   }
14467  JITTER_INSTRUCTION_EPILOG_(gtiu, gtiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14468 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14469 
14470   JITTER_INSTRUCTION_PROLOG_(gtl, gtl, hot)
14471   {
14472     /* This specialized instruction is not a replacement. */
14473 #   undef JITTER_BRANCH_FAST
14474 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14475 #   undef JITTER_BRANCH_FAST_IF_ZERO
14476 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14477 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14478 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14479 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14480 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14481 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14482 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14483 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14484 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14485 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14486 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14487 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14488 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14489 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14490 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14491 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14492 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14493 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14494 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14495 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14496 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14497 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14498 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14499 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14500 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14501 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14502 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14503 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14504 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14505 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14506 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14507 #   undef JITTER_BRANCH_FAST_IF_AND
14508 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14509 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14510 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14511 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14512 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14513 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14514 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14515 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14516 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14517 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14518 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14519 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14520 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14521 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14522 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14523 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14524 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14525 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14526 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14527 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14528 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14529 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14530 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14531 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14532 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14533 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14534 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14535 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14536 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14537 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       91
14538 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gtl
14539 
14540 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gtl
14541 
14542   /* The residual arity for this instruction does not depend on fast labels. */
14543   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14544 
14545 
14546 #if defined (JITTER_PROFILE_SAMPLE)
14547   JITTER_PROFILE_SAMPLE_UPDATE
14548      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14549       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14550   /* Force the compiler not move sample-profiling instrumentation
14551      beyond this point; this way the actual user code is timed.
14552      This is still not perfect, as residuals are materialised before
14553      we arrive here, but should be adequate at least for slow VM
14554      instructions. */
14555   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14556 #endif
14557 #if defined (JITTER_PROFILE_COUNT)
14558   /* Notice that, differently from the code above, this
14559      instrumentation code *can* be reordered freely: as long as a
14560      VM instruction is counted, the count increment can be placed
14561      anyehere.  Let GCC move this code and possibly achieve better
14562      throughput by exploiting instruction-level parallelism and
14563      therefore approximate more closely a non-profiled build. */
14564   JITTER_PROFILE_COUNT_UPDATE
14565      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14566       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14567 #endif
14568 
14569 /* User-specified code, instruction-beginning-c part: beginning. */
14570 
14571 /* User-specified code, instruction-beginning-c part: end */
14572 
14573 
14574     /* User code for gtl . */
14575 #line 2975 "../../libpoke/pvm.jitter"
14576 
14577      PVM_BOOL_BINOP (LONG, >);
14578 
14579     /* End of the user code for gtl . */
14580 
14581 /* User-specified code, instruction-end-c part: beginning. */
14582 
14583 /* User-specified code, instruction-end-c part: end */
14584 
14585     /* Undefine the gtl argument macros so they can't be used
14586        by mistake in the instruction body coming next. */
14587 
14588 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14589 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14590 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14591 
14592   }
14593  JITTER_INSTRUCTION_EPILOG_(gtl, gtl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14594 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14595 
14596   JITTER_INSTRUCTION_PROLOG_(gtlu, gtlu, hot)
14597   {
14598     /* This specialized instruction is not a replacement. */
14599 #   undef JITTER_BRANCH_FAST
14600 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14601 #   undef JITTER_BRANCH_FAST_IF_ZERO
14602 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14603 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14604 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14605 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14606 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14607 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14608 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14609 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14610 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14611 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14612 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14613 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14614 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14615 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14616 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14617 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14618 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14619 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14620 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14621 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14622 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14623 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14624 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14625 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14626 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14627 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14628 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14629 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14630 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14631 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14632 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14633 #   undef JITTER_BRANCH_FAST_IF_AND
14634 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14635 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14636 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14637 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14638 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14639 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14640 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14641 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14642 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14643 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14644 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14645 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14646 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14647 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14648 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14649 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14650 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14651 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14652 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14653 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14654 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14655 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14656 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14657 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14658 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14659 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14660 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14661 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14662 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14663 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       92
14664 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gtlu
14665 
14666 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gtlu
14667 
14668   /* The residual arity for this instruction does not depend on fast labels. */
14669   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14670 
14671 
14672 #if defined (JITTER_PROFILE_SAMPLE)
14673   JITTER_PROFILE_SAMPLE_UPDATE
14674      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14675       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14676   /* Force the compiler not move sample-profiling instrumentation
14677      beyond this point; this way the actual user code is timed.
14678      This is still not perfect, as residuals are materialised before
14679      we arrive here, but should be adequate at least for slow VM
14680      instructions. */
14681   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14682 #endif
14683 #if defined (JITTER_PROFILE_COUNT)
14684   /* Notice that, differently from the code above, this
14685      instrumentation code *can* be reordered freely: as long as a
14686      VM instruction is counted, the count increment can be placed
14687      anyehere.  Let GCC move this code and possibly achieve better
14688      throughput by exploiting instruction-level parallelism and
14689      therefore approximate more closely a non-profiled build. */
14690   JITTER_PROFILE_COUNT_UPDATE
14691      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14692       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14693 #endif
14694 
14695 /* User-specified code, instruction-beginning-c part: beginning. */
14696 
14697 /* User-specified code, instruction-beginning-c part: end */
14698 
14699 
14700     /* User code for gtlu . */
14701 #line 2988 "../../libpoke/pvm.jitter"
14702 
14703      PVM_BOOL_BINOP (ULONG, >);
14704 
14705     /* End of the user code for gtlu . */
14706 
14707 /* User-specified code, instruction-end-c part: beginning. */
14708 
14709 /* User-specified code, instruction-end-c part: end */
14710 
14711     /* Undefine the gtlu argument macros so they can't be used
14712        by mistake in the instruction body coming next. */
14713 
14714 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14715 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14716 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14717 
14718   }
14719  JITTER_INSTRUCTION_EPILOG_(gtlu, gtlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14720 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14721 
14722   JITTER_INSTRUCTION_PROLOG_(gts, gts, hot)
14723   {
14724     /* This specialized instruction is not a replacement. */
14725 #   undef JITTER_BRANCH_FAST
14726 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14727 #   undef JITTER_BRANCH_FAST_IF_ZERO
14728 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14729 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14730 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14731 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14732 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14733 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14734 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14735 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14736 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14737 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14738 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14739 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14740 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14741 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14742 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14743 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14744 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14745 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14746 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14747 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14748 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14749 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14750 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14751 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14752 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14753 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14754 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14755 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14756 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14757 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14758 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14759 #   undef JITTER_BRANCH_FAST_IF_AND
14760 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14761 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14762 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14763 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14764 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14765 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14766 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14767 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14768 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14769 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14770 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14771 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14772 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14773 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14774 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14775 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14776 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14777 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14778 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14779 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14780 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14781 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14782 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14783 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14784 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14785 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14786 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14787 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14788 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14789 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       93
14790 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gts
14791 
14792 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gts
14793 
14794   /* The residual arity for this instruction does not depend on fast labels. */
14795   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14796 
14797 
14798 #if defined (JITTER_PROFILE_SAMPLE)
14799   JITTER_PROFILE_SAMPLE_UPDATE
14800      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14801       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14802   /* Force the compiler not move sample-profiling instrumentation
14803      beyond this point; this way the actual user code is timed.
14804      This is still not perfect, as residuals are materialised before
14805      we arrive here, but should be adequate at least for slow VM
14806      instructions. */
14807   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14808 #endif
14809 #if defined (JITTER_PROFILE_COUNT)
14810   /* Notice that, differently from the code above, this
14811      instrumentation code *can* be reordered freely: as long as a
14812      VM instruction is counted, the count increment can be placed
14813      anyehere.  Let GCC move this code and possibly achieve better
14814      throughput by exploiting instruction-level parallelism and
14815      therefore approximate more closely a non-profiled build. */
14816   JITTER_PROFILE_COUNT_UPDATE
14817      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14818       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14819 #endif
14820 
14821 /* User-specified code, instruction-beginning-c part: beginning. */
14822 
14823 /* User-specified code, instruction-beginning-c part: end */
14824 
14825 
14826     /* User code for gts . */
14827 #line 3069 "../../libpoke/pvm.jitter"
14828 
14829     pvm_val res = PVM_MAKE_INT (strcmp (PVM_VAL_STR (JITTER_UNDER_TOP_STACK ()),
14830                                         PVM_VAL_STR (JITTER_TOP_STACK ())) > 0, 32);
14831     JITTER_PUSH_STACK (res);
14832 
14833     /* End of the user code for gts . */
14834 
14835 /* User-specified code, instruction-end-c part: beginning. */
14836 
14837 /* User-specified code, instruction-end-c part: end */
14838 
14839     /* Undefine the gts argument macros so they can't be used
14840        by mistake in the instruction body coming next. */
14841 
14842 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14843 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14844 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14845 
14846   }
14847  JITTER_INSTRUCTION_EPILOG_(gts, gts, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14848 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14849 
14850   JITTER_INSTRUCTION_PROLOG_(indent, indent, hot)
14851   {
14852     /* This specialized instruction is not a replacement. */
14853 #   undef JITTER_BRANCH_FAST
14854 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14855 #   undef JITTER_BRANCH_FAST_IF_ZERO
14856 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14857 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14858 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14859 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14860 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14861 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14862 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14863 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14864 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14865 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14866 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14867 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14868 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14869 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14870 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14871 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14872 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14873 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14874 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14875 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14876 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14877 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14878 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14879 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14880 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14881 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14882 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14883 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14884 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14885 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14886 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14887 #   undef JITTER_BRANCH_FAST_IF_AND
14888 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14889 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14890 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14891 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14892 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14893 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14894 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14895 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14896 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14897 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14898 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14899 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14900 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14901 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14902 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14903 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14904 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14905 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14906 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14907 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14908 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14909 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14910 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14911 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14912 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14913 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14914 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14915 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14916 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14917 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       94
14918 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         indent
14919 
14920 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME indent
14921 
14922   /* The residual arity for this instruction does not depend on fast labels. */
14923   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14924 
14925 
14926 #if defined (JITTER_PROFILE_SAMPLE)
14927   JITTER_PROFILE_SAMPLE_UPDATE
14928      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14929       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14930   /* Force the compiler not move sample-profiling instrumentation
14931      beyond this point; this way the actual user code is timed.
14932      This is still not perfect, as residuals are materialised before
14933      we arrive here, but should be adequate at least for slow VM
14934      instructions. */
14935   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14936 #endif
14937 #if defined (JITTER_PROFILE_COUNT)
14938   /* Notice that, differently from the code above, this
14939      instrumentation code *can* be reordered freely: as long as a
14940      VM instruction is counted, the count increment can be placed
14941      anyehere.  Let GCC move this code and possibly achieve better
14942      throughput by exploiting instruction-level parallelism and
14943      therefore approximate more closely a non-profiled build. */
14944   JITTER_PROFILE_COUNT_UPDATE
14945      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14946       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14947 #endif
14948 
14949 /* User-specified code, instruction-beginning-c part: beginning. */
14950 
14951 /* User-specified code, instruction-beginning-c part: end */
14952 
14953 
14954     /* User code for indent . */
14955 #line 1763 "../../libpoke/pvm.jitter"
14956 
14957     pk_term_indent (PVM_VAL_INT (JITTER_UNDER_TOP_STACK ()),
14958                     PVM_VAL_INT (JITTER_TOP_STACK ()));
14959     JITTER_DROP_STACK ();
14960     JITTER_DROP_STACK ();
14961 
14962     /* End of the user code for indent . */
14963 
14964 /* User-specified code, instruction-end-c part: beginning. */
14965 
14966 /* User-specified code, instruction-end-c part: end */
14967 
14968     /* Undefine the indent argument macros so they can't be used
14969        by mistake in the instruction body coming next. */
14970 
14971 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14972 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14973 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14974 
14975   }
14976  JITTER_INSTRUCTION_EPILOG_(indent, indent, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14977 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14978 
14979   JITTER_INSTRUCTION_PROLOG_(iogetb, iogetb, hot)
14980   {
14981     /* This specialized instruction is not a replacement. */
14982 #   undef JITTER_BRANCH_FAST
14983 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14984 #   undef JITTER_BRANCH_FAST_IF_ZERO
14985 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14986 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14987 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14988 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14989 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14990 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14991 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14992 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14993 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14994 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14995 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14996 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14997 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14998 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14999 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15000 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15001 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15002 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15003 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15004 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15005 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15006 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15007 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15008 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15009 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15010 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15011 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15012 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15013 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15014 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15015 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15016 #   undef JITTER_BRANCH_FAST_IF_AND
15017 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15018 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15019 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15020 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15021 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15022 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15023 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15024 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15025 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15026 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15027 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15028 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15029 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15030 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15031 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15032 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15033 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15034 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15035 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15036 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15037 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15038 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15039 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15040 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15041 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15042 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15043 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15044 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15045 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15046 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       95
15047 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         iogetb
15048 
15049 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME iogetb
15050 
15051   /* The residual arity for this instruction does not depend on fast labels. */
15052   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15053 
15054 
15055 #if defined (JITTER_PROFILE_SAMPLE)
15056   JITTER_PROFILE_SAMPLE_UPDATE
15057      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15058       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15059   /* Force the compiler not move sample-profiling instrumentation
15060      beyond this point; this way the actual user code is timed.
15061      This is still not perfect, as residuals are materialised before
15062      we arrive here, but should be adequate at least for slow VM
15063      instructions. */
15064   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15065 #endif
15066 #if defined (JITTER_PROFILE_COUNT)
15067   /* Notice that, differently from the code above, this
15068      instrumentation code *can* be reordered freely: as long as a
15069      VM instruction is counted, the count increment can be placed
15070      anyehere.  Let GCC move this code and possibly achieve better
15071      throughput by exploiting instruction-level parallelism and
15072      therefore approximate more closely a non-profiled build. */
15073   JITTER_PROFILE_COUNT_UPDATE
15074      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15075       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15076 #endif
15077 
15078 /* User-specified code, instruction-beginning-c part: beginning. */
15079 
15080 /* User-specified code, instruction-beginning-c part: end */
15081 
15082 
15083     /* User code for iogetb . */
15084 #line 1498 "../../libpoke/pvm.jitter"
15085 
15086     ios io = ios_search_by_id (PVM_VAL_INT (JITTER_TOP_STACK ()));
15087 
15088     if (io == NULL)
15089       PVM_RAISE_DFL (PVM_E_NO_IOS);
15090 
15091     JITTER_PUSH_STACK (pvm_make_offset (PVM_MAKE_ULONG (ios_get_bias (io), 64),
15092                                         PVM_MAKE_ULONG (1, 64)));
15093 
15094     /* End of the user code for iogetb . */
15095 
15096 /* User-specified code, instruction-end-c part: beginning. */
15097 
15098 /* User-specified code, instruction-end-c part: end */
15099 
15100     /* Undefine the iogetb argument macros so they can't be used
15101        by mistake in the instruction body coming next. */
15102 
15103 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15104 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15105 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15106 
15107   }
15108  JITTER_INSTRUCTION_EPILOG_(iogetb, iogetb, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15109 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15110 
15111   JITTER_INSTRUCTION_PROLOG_(iosetb, iosetb, hot)
15112   {
15113     /* This specialized instruction is not a replacement. */
15114 #   undef JITTER_BRANCH_FAST
15115 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15116 #   undef JITTER_BRANCH_FAST_IF_ZERO
15117 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15118 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15119 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15120 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15121 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15122 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15123 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15124 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15125 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15126 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15127 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15128 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15129 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15130 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15131 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15132 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15133 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15134 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15135 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15136 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15137 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15138 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15139 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15140 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15141 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15142 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15143 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15144 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15145 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15146 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15147 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15148 #   undef JITTER_BRANCH_FAST_IF_AND
15149 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15150 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15151 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15152 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15153 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15154 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15155 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15156 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15157 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15158 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15159 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15160 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15161 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15162 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15163 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15164 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15165 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15166 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15167 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15168 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15169 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15170 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15171 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15172 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15173 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15174 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15175 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15176 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15177 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15178 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       96
15179 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         iosetb
15180 
15181 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME iosetb
15182 
15183   /* The residual arity for this instruction does not depend on fast labels. */
15184   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15185 
15186 
15187 #if defined (JITTER_PROFILE_SAMPLE)
15188   JITTER_PROFILE_SAMPLE_UPDATE
15189      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15190       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15191   /* Force the compiler not move sample-profiling instrumentation
15192      beyond this point; this way the actual user code is timed.
15193      This is still not perfect, as residuals are materialised before
15194      we arrive here, but should be adequate at least for slow VM
15195      instructions. */
15196   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15197 #endif
15198 #if defined (JITTER_PROFILE_COUNT)
15199   /* Notice that, differently from the code above, this
15200      instrumentation code *can* be reordered freely: as long as a
15201      VM instruction is counted, the count increment can be placed
15202      anyehere.  Let GCC move this code and possibly achieve better
15203      throughput by exploiting instruction-level parallelism and
15204      therefore approximate more closely a non-profiled build. */
15205   JITTER_PROFILE_COUNT_UPDATE
15206      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15207       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15208 #endif
15209 
15210 /* User-specified code, instruction-beginning-c part: beginning. */
15211 
15212 /* User-specified code, instruction-beginning-c part: end */
15213 
15214 
15215     /* User code for iosetb . */
15216 #line 1523 "../../libpoke/pvm.jitter"
15217 
15218     pvm_val bias = JITTER_TOP_STACK();
15219     ios io = ios_search_by_id (PVM_VAL_INT (JITTER_UNDER_TOP_STACK ()));
15220 
15221     JITTER_DROP_STACK ();
15222 
15223     if (io == NULL)
15224       PVM_RAISE_DFL (PVM_E_NO_IOS);
15225 
15226     ios_set_bias (io,
15227                   (PVM_VAL_INTEGRAL (PVM_VAL_OFF_MAGNITUDE (bias))
15228                    * PVM_VAL_INTEGRAL (PVM_VAL_OFF_UNIT (bias))));
15229 
15230     /* End of the user code for iosetb . */
15231 
15232 /* User-specified code, instruction-end-c part: beginning. */
15233 
15234 /* User-specified code, instruction-end-c part: end */
15235 
15236     /* Undefine the iosetb argument macros so they can't be used
15237        by mistake in the instruction body coming next. */
15238 
15239 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15240 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15241 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15242 
15243   }
15244  JITTER_INSTRUCTION_EPILOG_(iosetb, iosetb, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15245 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15246 
15247   JITTER_INSTRUCTION_PROLOG_(iosize, iosize, hot)
15248   {
15249     /* This specialized instruction is not a replacement. */
15250 #   undef JITTER_BRANCH_FAST
15251 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15252 #   undef JITTER_BRANCH_FAST_IF_ZERO
15253 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15254 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15255 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15256 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15257 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15258 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15259 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15260 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15261 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15262 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15263 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15264 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15265 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15266 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15267 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15268 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15269 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15270 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15271 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15272 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15273 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15274 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15275 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15276 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15277 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15278 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15279 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15280 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15281 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15282 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15283 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15284 #   undef JITTER_BRANCH_FAST_IF_AND
15285 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15286 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15287 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15288 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15289 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15290 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15291 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15292 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15293 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15294 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15295 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15296 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15297 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15298 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15299 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15300 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15301 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15302 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15303 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15304 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15305 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15306 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15307 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15308 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15309 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15310 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15311 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15312 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15313 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15314 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       97
15315 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         iosize
15316 
15317 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME iosize
15318 
15319   /* The residual arity for this instruction does not depend on fast labels. */
15320   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15321 
15322 
15323 #if defined (JITTER_PROFILE_SAMPLE)
15324   JITTER_PROFILE_SAMPLE_UPDATE
15325      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15326       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15327   /* Force the compiler not move sample-profiling instrumentation
15328      beyond this point; this way the actual user code is timed.
15329      This is still not perfect, as residuals are materialised before
15330      we arrive here, but should be adequate at least for slow VM
15331      instructions. */
15332   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15333 #endif
15334 #if defined (JITTER_PROFILE_COUNT)
15335   /* Notice that, differently from the code above, this
15336      instrumentation code *can* be reordered freely: as long as a
15337      VM instruction is counted, the count increment can be placed
15338      anyehere.  Let GCC move this code and possibly achieve better
15339      throughput by exploiting instruction-level parallelism and
15340      therefore approximate more closely a non-profiled build. */
15341   JITTER_PROFILE_COUNT_UPDATE
15342      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15343       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15344 #endif
15345 
15346 /* User-specified code, instruction-beginning-c part: beginning. */
15347 
15348 /* User-specified code, instruction-beginning-c part: end */
15349 
15350 
15351     /* User code for iosize . */
15352 #line 1472 "../../libpoke/pvm.jitter"
15353 
15354     ios io = ios_search_by_id (PVM_VAL_INT (JITTER_TOP_STACK ()));
15355 
15356     if (io == NULL)
15357       PVM_RAISE_DFL (PVM_E_NO_IOS);
15358 
15359     JITTER_PUSH_STACK (pvm_make_offset (PVM_MAKE_ULONG (ios_size (io), 64),
15360                                         PVM_MAKE_ULONG (1, 64)));
15361 
15362     /* End of the user code for iosize . */
15363 
15364 /* User-specified code, instruction-end-c part: beginning. */
15365 
15366 /* User-specified code, instruction-end-c part: end */
15367 
15368     /* Undefine the iosize argument macros so they can't be used
15369        by mistake in the instruction body coming next. */
15370 
15371 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15372 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15373 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15374 
15375   }
15376  JITTER_INSTRUCTION_EPILOG_(iosize, iosize, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15377 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15378 
15379   JITTER_INSTRUCTION_PROLOG_(isa, isa, hot)
15380   {
15381     /* This specialized instruction is not a replacement. */
15382 #   undef JITTER_BRANCH_FAST
15383 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15384 #   undef JITTER_BRANCH_FAST_IF_ZERO
15385 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15386 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15387 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15388 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15389 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15390 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15391 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15392 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15393 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15394 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15395 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15396 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15397 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15398 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15399 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15400 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15401 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15402 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15403 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15404 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15405 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15406 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15407 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15408 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15409 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15410 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15411 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15412 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15413 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15414 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15415 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15416 #   undef JITTER_BRANCH_FAST_IF_AND
15417 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15418 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15419 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15420 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15421 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15422 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15423 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15424 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15425 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15426 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15427 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15428 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15429 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15430 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15431 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15432 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15433 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15434 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15435 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15436 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15437 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15438 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15439 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15440 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15441 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15442 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15443 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15444 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15445 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15446 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       98
15447 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         isa
15448 
15449 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME isa
15450 
15451   /* The residual arity for this instruction does not depend on fast labels. */
15452   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15453 
15454 
15455 #if defined (JITTER_PROFILE_SAMPLE)
15456   JITTER_PROFILE_SAMPLE_UPDATE
15457      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15458       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15459   /* Force the compiler not move sample-profiling instrumentation
15460      beyond this point; this way the actual user code is timed.
15461      This is still not perfect, as residuals are materialised before
15462      we arrive here, but should be adequate at least for slow VM
15463      instructions. */
15464   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15465 #endif
15466 #if defined (JITTER_PROFILE_COUNT)
15467   /* Notice that, differently from the code above, this
15468      instrumentation code *can* be reordered freely: as long as a
15469      VM instruction is counted, the count increment can be placed
15470      anyehere.  Let GCC move this code and possibly achieve better
15471      throughput by exploiting instruction-level parallelism and
15472      therefore approximate more closely a non-profiled build. */
15473   JITTER_PROFILE_COUNT_UPDATE
15474      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15475       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15476 #endif
15477 
15478 /* User-specified code, instruction-beginning-c part: beginning. */
15479 
15480 /* User-specified code, instruction-beginning-c part: end */
15481 
15482 
15483     /* User code for isa . */
15484 #line 4976 "../../libpoke/pvm.jitter"
15485 
15486     pvm_val type = JITTER_TOP_STACK ();
15487     pvm_val val = JITTER_UNDER_TOP_STACK ();
15488     pvm_val val_type = pvm_typeof (val);
15489 
15490     JITTER_PUSH_STACK (PVM_MAKE_INT (pvm_type_equal_p (type, val_type),
15491                                      32));
15492 
15493     /* End of the user code for isa . */
15494 
15495 /* User-specified code, instruction-end-c part: beginning. */
15496 
15497 /* User-specified code, instruction-end-c part: end */
15498 
15499     /* Undefine the isa argument macros so they can't be used
15500        by mistake in the instruction body coming next. */
15501 
15502 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15503 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15504 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15505 
15506   }
15507  JITTER_INSTRUCTION_EPILOG_(isa, isa, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15508 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15509 
15510   JITTER_INSTRUCTION_PROLOG_(itoi/nR, itoi__nR, cold)
15511   {
15512     /* This specialized instruction is not a replacement. */
15513 #   undef JITTER_BRANCH_FAST
15514 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15515 #   undef JITTER_BRANCH_FAST_IF_ZERO
15516 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15517 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15518 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15519 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15520 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15521 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15522 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15523 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15524 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15525 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15526 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15527 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15528 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15529 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15530 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15531 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15532 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15533 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15534 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15535 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15536 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15537 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15538 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15539 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15540 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15541 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15542 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15543 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15544 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15545 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15546 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15547 #   undef JITTER_BRANCH_FAST_IF_AND
15548 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15549 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15550 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15551 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15552 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15553 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15554 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15555 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15556 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15557 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15558 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15559 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15560 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15561 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15562 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15563 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15564 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15565 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15566 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15567 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15568 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15569 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15570 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15571 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15572 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15573 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15574 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15575 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15576 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15577 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       99
15578 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         itoi/nR
15579 
15580 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME itoi__nR
15581 
15582   /* The residual arity for this instruction does not depend on fast labels. */
15583   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15584 
15585     /* The 0th argument is a residual literal. */
15586 #if defined(JITTER_DISPATCH_NO_THREADING)
15587 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
15588     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15589 #elif defined (JITTER_REPLICATE)
15590 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
15591 #else
15592 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
15593 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15594 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15595 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15596 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15597 #   define JITTER_ARGF0 JITTER_ARGP0
15598 
15599 
15600 #if defined (JITTER_PROFILE_SAMPLE)
15601   JITTER_PROFILE_SAMPLE_UPDATE
15602      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15603       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15604   /* Force the compiler not move sample-profiling instrumentation
15605      beyond this point; this way the actual user code is timed.
15606      This is still not perfect, as residuals are materialised before
15607      we arrive here, but should be adequate at least for slow VM
15608      instructions. */
15609   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15610 #endif
15611 #if defined (JITTER_PROFILE_COUNT)
15612   /* Notice that, differently from the code above, this
15613      instrumentation code *can* be reordered freely: as long as a
15614      VM instruction is counted, the count increment can be placed
15615      anyehere.  Let GCC move this code and possibly achieve better
15616      throughput by exploiting instruction-level parallelism and
15617      therefore approximate more closely a non-profiled build. */
15618   JITTER_PROFILE_COUNT_UPDATE
15619      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15620       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15621 #endif
15622 
15623 /* User-specified code, instruction-beginning-c part: beginning. */
15624 
15625 /* User-specified code, instruction-beginning-c part: end */
15626 
15627 
15628     /* User code for itoi/nR . */
15629 #line 3765 "../../libpoke/pvm.jitter"
15630 
15631     PVM_CONVOP (INT, int32_t, int, int32_t);
15632 
15633     /* End of the user code for itoi/nR . */
15634 
15635 /* User-specified code, instruction-end-c part: beginning. */
15636 
15637 /* User-specified code, instruction-end-c part: end */
15638 
15639     /* Undefine the itoi/nR argument macros so they can't be used
15640        by mistake in the instruction body coming next. */
15641 #   undef JITTER_SLOW_REGISTER_OFFSET0
15642 #   undef JITTER_ARG0
15643 #   undef JITTER_ARGN0
15644 #   undef JITTER_ARGU0
15645 #   undef JITTER_ARGP0
15646 #   undef JITTER_ARGF0
15647 
15648 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15649 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15650 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15651 
15652   }
15653  JITTER_INSTRUCTION_EPILOG_(itoi/nR, itoi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15654 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15655 
15656   JITTER_INSTRUCTION_PROLOG_(itoiu/nR, itoiu__nR, cold)
15657   {
15658     /* This specialized instruction is not a replacement. */
15659 #   undef JITTER_BRANCH_FAST
15660 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15661 #   undef JITTER_BRANCH_FAST_IF_ZERO
15662 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15663 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15664 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15665 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15666 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15667 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15668 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15669 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15670 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15671 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15672 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15673 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15674 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15675 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15676 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15677 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15678 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15679 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15680 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15681 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15682 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15683 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15684 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15685 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15686 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15687 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15688 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15689 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15690 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15691 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15692 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15693 #   undef JITTER_BRANCH_FAST_IF_AND
15694 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15695 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15696 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15697 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15698 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15699 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15700 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15701 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15702 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15703 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15704 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15705 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15706 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15707 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15708 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15709 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15710 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15711 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15712 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15713 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15714 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15715 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15716 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15717 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15718 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15719 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15720 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15721 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15722 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15723 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       100
15724 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         itoiu/nR
15725 
15726 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME itoiu__nR
15727 
15728   /* The residual arity for this instruction does not depend on fast labels. */
15729   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15730 
15731     /* The 0th argument is a residual literal. */
15732 #if defined(JITTER_DISPATCH_NO_THREADING)
15733 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
15734     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15735 #elif defined (JITTER_REPLICATE)
15736 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
15737 #else
15738 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
15739 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15740 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15741 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15742 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15743 #   define JITTER_ARGF0 JITTER_ARGP0
15744 
15745 
15746 #if defined (JITTER_PROFILE_SAMPLE)
15747   JITTER_PROFILE_SAMPLE_UPDATE
15748      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15749       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15750   /* Force the compiler not move sample-profiling instrumentation
15751      beyond this point; this way the actual user code is timed.
15752      This is still not perfect, as residuals are materialised before
15753      we arrive here, but should be adequate at least for slow VM
15754      instructions. */
15755   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15756 #endif
15757 #if defined (JITTER_PROFILE_COUNT)
15758   /* Notice that, differently from the code above, this
15759      instrumentation code *can* be reordered freely: as long as a
15760      VM instruction is counted, the count increment can be placed
15761      anyehere.  Let GCC move this code and possibly achieve better
15762      throughput by exploiting instruction-level parallelism and
15763      therefore approximate more closely a non-profiled build. */
15764   JITTER_PROFILE_COUNT_UPDATE
15765      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15766       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15767 #endif
15768 
15769 /* User-specified code, instruction-beginning-c part: beginning. */
15770 
15771 /* User-specified code, instruction-beginning-c part: end */
15772 
15773 
15774     /* User code for itoiu/nR . */
15775 #line 3780 "../../libpoke/pvm.jitter"
15776 
15777     PVM_CONVOP (INT, int32_t, uint, uint32_t);
15778 
15779     /* End of the user code for itoiu/nR . */
15780 
15781 /* User-specified code, instruction-end-c part: beginning. */
15782 
15783 /* User-specified code, instruction-end-c part: end */
15784 
15785     /* Undefine the itoiu/nR argument macros so they can't be used
15786        by mistake in the instruction body coming next. */
15787 #   undef JITTER_SLOW_REGISTER_OFFSET0
15788 #   undef JITTER_ARG0
15789 #   undef JITTER_ARGN0
15790 #   undef JITTER_ARGU0
15791 #   undef JITTER_ARGP0
15792 #   undef JITTER_ARGF0
15793 
15794 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15795 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15796 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15797 
15798   }
15799  JITTER_INSTRUCTION_EPILOG_(itoiu/nR, itoiu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15800 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15801 
15802   JITTER_INSTRUCTION_PROLOG_(itol/nR, itol__nR, cold)
15803   {
15804     /* This specialized instruction is not a replacement. */
15805 #   undef JITTER_BRANCH_FAST
15806 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15807 #   undef JITTER_BRANCH_FAST_IF_ZERO
15808 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15809 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15810 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15811 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15812 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15813 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15814 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15815 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15816 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15817 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15818 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15819 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15820 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15821 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15822 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15823 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15824 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15825 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15826 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15827 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15828 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15829 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15830 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15831 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15832 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15833 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15834 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15835 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15836 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15837 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15838 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15839 #   undef JITTER_BRANCH_FAST_IF_AND
15840 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15841 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15842 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15843 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15844 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15845 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15846 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15847 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15848 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15849 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15850 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15851 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15852 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15853 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15854 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15855 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15856 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15857 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15858 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15859 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15860 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15861 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15862 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15863 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15864 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15865 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15866 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15867 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15868 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15869 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       101
15870 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         itol/nR
15871 
15872 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME itol__nR
15873 
15874   /* The residual arity for this instruction does not depend on fast labels. */
15875   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15876 
15877     /* The 0th argument is a residual literal. */
15878 #if defined(JITTER_DISPATCH_NO_THREADING)
15879 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
15880     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15881 #elif defined (JITTER_REPLICATE)
15882 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
15883 #else
15884 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
15885 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15886 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15887 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15888 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15889 #   define JITTER_ARGF0 JITTER_ARGP0
15890 
15891 
15892 #if defined (JITTER_PROFILE_SAMPLE)
15893   JITTER_PROFILE_SAMPLE_UPDATE
15894      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15895       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15896   /* Force the compiler not move sample-profiling instrumentation
15897      beyond this point; this way the actual user code is timed.
15898      This is still not perfect, as residuals are materialised before
15899      we arrive here, but should be adequate at least for slow VM
15900      instructions. */
15901   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15902 #endif
15903 #if defined (JITTER_PROFILE_COUNT)
15904   /* Notice that, differently from the code above, this
15905      instrumentation code *can* be reordered freely: as long as a
15906      VM instruction is counted, the count increment can be placed
15907      anyehere.  Let GCC move this code and possibly achieve better
15908      throughput by exploiting instruction-level parallelism and
15909      therefore approximate more closely a non-profiled build. */
15910   JITTER_PROFILE_COUNT_UPDATE
15911      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15912       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15913 #endif
15914 
15915 /* User-specified code, instruction-beginning-c part: beginning. */
15916 
15917 /* User-specified code, instruction-beginning-c part: end */
15918 
15919 
15920     /* User code for itol/nR . */
15921 #line 3795 "../../libpoke/pvm.jitter"
15922 
15923     PVM_CONVOP (INT, int32_t, long, int64_t);
15924 
15925     /* End of the user code for itol/nR . */
15926 
15927 /* User-specified code, instruction-end-c part: beginning. */
15928 
15929 /* User-specified code, instruction-end-c part: end */
15930 
15931     /* Undefine the itol/nR argument macros so they can't be used
15932        by mistake in the instruction body coming next. */
15933 #   undef JITTER_SLOW_REGISTER_OFFSET0
15934 #   undef JITTER_ARG0
15935 #   undef JITTER_ARGN0
15936 #   undef JITTER_ARGU0
15937 #   undef JITTER_ARGP0
15938 #   undef JITTER_ARGF0
15939 
15940 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15941 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15942 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15943 
15944   }
15945  JITTER_INSTRUCTION_EPILOG_(itol/nR, itol__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15946 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15947 
15948   JITTER_INSTRUCTION_PROLOG_(itolu/nR, itolu__nR, cold)
15949   {
15950     /* This specialized instruction is not a replacement. */
15951 #   undef JITTER_BRANCH_FAST
15952 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15953 #   undef JITTER_BRANCH_FAST_IF_ZERO
15954 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15955 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15956 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15957 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15958 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15959 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15960 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15961 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15962 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15963 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15964 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15965 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15966 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15967 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15968 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15969 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15970 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15971 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15972 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15973 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15974 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15975 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15976 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15977 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15978 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15979 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15980 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15981 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15982 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15983 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15984 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15985 #   undef JITTER_BRANCH_FAST_IF_AND
15986 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15987 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15988 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15989 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15990 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15991 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15992 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15993 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15994 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15995 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15996 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15997 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15998 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15999 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16000 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16001 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16002 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16003 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16004 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16005 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16006 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16007 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16008 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16009 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16010 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16011 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16012 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16013 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16014 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16015 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       102
16016 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         itolu/nR
16017 
16018 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME itolu__nR
16019 
16020   /* The residual arity for this instruction does not depend on fast labels. */
16021   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16022 
16023     /* The 0th argument is a residual literal. */
16024 #if defined(JITTER_DISPATCH_NO_THREADING)
16025 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
16026     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16027 #elif defined (JITTER_REPLICATE)
16028 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
16029 #else
16030 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
16031 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16032 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16033 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16034 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16035 #   define JITTER_ARGF0 JITTER_ARGP0
16036 
16037 
16038 #if defined (JITTER_PROFILE_SAMPLE)
16039   JITTER_PROFILE_SAMPLE_UPDATE
16040      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16041       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16042   /* Force the compiler not move sample-profiling instrumentation
16043      beyond this point; this way the actual user code is timed.
16044      This is still not perfect, as residuals are materialised before
16045      we arrive here, but should be adequate at least for slow VM
16046      instructions. */
16047   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16048 #endif
16049 #if defined (JITTER_PROFILE_COUNT)
16050   /* Notice that, differently from the code above, this
16051      instrumentation code *can* be reordered freely: as long as a
16052      VM instruction is counted, the count increment can be placed
16053      anyehere.  Let GCC move this code and possibly achieve better
16054      throughput by exploiting instruction-level parallelism and
16055      therefore approximate more closely a non-profiled build. */
16056   JITTER_PROFILE_COUNT_UPDATE
16057      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16058       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16059 #endif
16060 
16061 /* User-specified code, instruction-beginning-c part: beginning. */
16062 
16063 /* User-specified code, instruction-beginning-c part: end */
16064 
16065 
16066     /* User code for itolu/nR . */
16067 #line 3810 "../../libpoke/pvm.jitter"
16068 
16069     PVM_CONVOP (INT, int32_t, ulong, uint64_t);
16070 
16071     /* End of the user code for itolu/nR . */
16072 
16073 /* User-specified code, instruction-end-c part: beginning. */
16074 
16075 /* User-specified code, instruction-end-c part: end */
16076 
16077     /* Undefine the itolu/nR argument macros so they can't be used
16078        by mistake in the instruction body coming next. */
16079 #   undef JITTER_SLOW_REGISTER_OFFSET0
16080 #   undef JITTER_ARG0
16081 #   undef JITTER_ARGN0
16082 #   undef JITTER_ARGU0
16083 #   undef JITTER_ARGP0
16084 #   undef JITTER_ARGF0
16085 
16086 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16087 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16088 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16089 
16090   }
16091  JITTER_INSTRUCTION_EPILOG_(itolu/nR, itolu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16092 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16093 
16094   JITTER_INSTRUCTION_PROLOG_(iutoi/nR, iutoi__nR, cold)
16095   {
16096     /* This specialized instruction is not a replacement. */
16097 #   undef JITTER_BRANCH_FAST
16098 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16099 #   undef JITTER_BRANCH_FAST_IF_ZERO
16100 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16101 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16102 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16103 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16104 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16105 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16106 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16107 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16108 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16109 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16110 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16111 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16112 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16113 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16114 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16115 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16116 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16117 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16118 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16119 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16120 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16121 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16122 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16123 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16124 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16125 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16126 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16127 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16128 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16129 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16130 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16131 #   undef JITTER_BRANCH_FAST_IF_AND
16132 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16133 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16134 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16135 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16136 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16137 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16138 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16139 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16140 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16141 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16142 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16143 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16144 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16145 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16146 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16147 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16148 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16149 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16150 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16151 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16152 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16153 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16154 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16155 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16156 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16157 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16158 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16159 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16160 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16161 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       103
16162 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         iutoi/nR
16163 
16164 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME iutoi__nR
16165 
16166   /* The residual arity for this instruction does not depend on fast labels. */
16167   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16168 
16169     /* The 0th argument is a residual literal. */
16170 #if defined(JITTER_DISPATCH_NO_THREADING)
16171 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
16172     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16173 #elif defined (JITTER_REPLICATE)
16174 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
16175 #else
16176 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
16177 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16178 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16179 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16180 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16181 #   define JITTER_ARGF0 JITTER_ARGP0
16182 
16183 
16184 #if defined (JITTER_PROFILE_SAMPLE)
16185   JITTER_PROFILE_SAMPLE_UPDATE
16186      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16187       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16188   /* Force the compiler not move sample-profiling instrumentation
16189      beyond this point; this way the actual user code is timed.
16190      This is still not perfect, as residuals are materialised before
16191      we arrive here, but should be adequate at least for slow VM
16192      instructions. */
16193   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16194 #endif
16195 #if defined (JITTER_PROFILE_COUNT)
16196   /* Notice that, differently from the code above, this
16197      instrumentation code *can* be reordered freely: as long as a
16198      VM instruction is counted, the count increment can be placed
16199      anyehere.  Let GCC move this code and possibly achieve better
16200      throughput by exploiting instruction-level parallelism and
16201      therefore approximate more closely a non-profiled build. */
16202   JITTER_PROFILE_COUNT_UPDATE
16203      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16204       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16205 #endif
16206 
16207 /* User-specified code, instruction-beginning-c part: beginning. */
16208 
16209 /* User-specified code, instruction-beginning-c part: end */
16210 
16211 
16212     /* User code for iutoi/nR . */
16213 #line 3825 "../../libpoke/pvm.jitter"
16214 
16215     PVM_CONVOP (UINT, uint32_t, int, int32_t);
16216 
16217     /* End of the user code for iutoi/nR . */
16218 
16219 /* User-specified code, instruction-end-c part: beginning. */
16220 
16221 /* User-specified code, instruction-end-c part: end */
16222 
16223     /* Undefine the iutoi/nR argument macros so they can't be used
16224        by mistake in the instruction body coming next. */
16225 #   undef JITTER_SLOW_REGISTER_OFFSET0
16226 #   undef JITTER_ARG0
16227 #   undef JITTER_ARGN0
16228 #   undef JITTER_ARGU0
16229 #   undef JITTER_ARGP0
16230 #   undef JITTER_ARGF0
16231 
16232 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16233 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16234 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16235 
16236   }
16237  JITTER_INSTRUCTION_EPILOG_(iutoi/nR, iutoi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16238 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16239 
16240   JITTER_INSTRUCTION_PROLOG_(iutoiu/nR, iutoiu__nR, cold)
16241   {
16242     /* This specialized instruction is not a replacement. */
16243 #   undef JITTER_BRANCH_FAST
16244 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16245 #   undef JITTER_BRANCH_FAST_IF_ZERO
16246 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16247 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16248 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16249 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16250 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16251 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16252 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16253 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16254 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16255 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16256 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16257 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16258 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16259 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16260 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16261 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16262 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16263 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16264 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16265 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16266 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16267 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16268 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16269 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16270 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16271 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16272 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16273 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16274 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16275 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16276 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16277 #   undef JITTER_BRANCH_FAST_IF_AND
16278 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16279 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16280 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16281 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16282 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16283 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16284 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16285 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16286 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16287 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16288 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16289 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16290 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16291 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16292 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16293 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16294 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16295 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16296 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16297 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16298 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16299 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16300 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16301 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16302 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16303 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16304 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16305 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16306 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16307 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       104
16308 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         iutoiu/nR
16309 
16310 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME iutoiu__nR
16311 
16312   /* The residual arity for this instruction does not depend on fast labels. */
16313   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16314 
16315     /* The 0th argument is a residual literal. */
16316 #if defined(JITTER_DISPATCH_NO_THREADING)
16317 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
16318     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16319 #elif defined (JITTER_REPLICATE)
16320 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
16321 #else
16322 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
16323 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16324 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16325 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16326 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16327 #   define JITTER_ARGF0 JITTER_ARGP0
16328 
16329 
16330 #if defined (JITTER_PROFILE_SAMPLE)
16331   JITTER_PROFILE_SAMPLE_UPDATE
16332      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16333       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16334   /* Force the compiler not move sample-profiling instrumentation
16335      beyond this point; this way the actual user code is timed.
16336      This is still not perfect, as residuals are materialised before
16337      we arrive here, but should be adequate at least for slow VM
16338      instructions. */
16339   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16340 #endif
16341 #if defined (JITTER_PROFILE_COUNT)
16342   /* Notice that, differently from the code above, this
16343      instrumentation code *can* be reordered freely: as long as a
16344      VM instruction is counted, the count increment can be placed
16345      anyehere.  Let GCC move this code and possibly achieve better
16346      throughput by exploiting instruction-level parallelism and
16347      therefore approximate more closely a non-profiled build. */
16348   JITTER_PROFILE_COUNT_UPDATE
16349      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16350       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16351 #endif
16352 
16353 /* User-specified code, instruction-beginning-c part: beginning. */
16354 
16355 /* User-specified code, instruction-beginning-c part: end */
16356 
16357 
16358     /* User code for iutoiu/nR . */
16359 #line 3840 "../../libpoke/pvm.jitter"
16360 
16361     PVM_CONVOP (UINT, uint32_t, uint, uint32_t);
16362 
16363     /* End of the user code for iutoiu/nR . */
16364 
16365 /* User-specified code, instruction-end-c part: beginning. */
16366 
16367 /* User-specified code, instruction-end-c part: end */
16368 
16369     /* Undefine the iutoiu/nR argument macros so they can't be used
16370        by mistake in the instruction body coming next. */
16371 #   undef JITTER_SLOW_REGISTER_OFFSET0
16372 #   undef JITTER_ARG0
16373 #   undef JITTER_ARGN0
16374 #   undef JITTER_ARGU0
16375 #   undef JITTER_ARGP0
16376 #   undef JITTER_ARGF0
16377 
16378 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16379 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16380 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16381 
16382   }
16383  JITTER_INSTRUCTION_EPILOG_(iutoiu/nR, iutoiu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16384 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16385 
16386   JITTER_INSTRUCTION_PROLOG_(iutol/nR, iutol__nR, cold)
16387   {
16388     /* This specialized instruction is not a replacement. */
16389 #   undef JITTER_BRANCH_FAST
16390 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16391 #   undef JITTER_BRANCH_FAST_IF_ZERO
16392 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16393 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16394 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16395 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16396 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16397 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16398 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16399 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16400 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16401 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16402 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16403 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16404 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16405 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16406 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16407 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16408 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16409 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16410 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16411 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16412 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16413 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16414 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16415 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16416 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16417 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16418 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16419 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16420 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16421 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16422 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16423 #   undef JITTER_BRANCH_FAST_IF_AND
16424 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16425 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16426 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16427 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16428 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16429 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16430 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16431 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16432 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16433 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16434 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16435 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16436 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16437 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16438 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16439 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16440 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16441 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16442 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16443 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16444 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16445 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16446 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16447 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16448 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16449 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16450 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16451 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16452 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16453 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       105
16454 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         iutol/nR
16455 
16456 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME iutol__nR
16457 
16458   /* The residual arity for this instruction does not depend on fast labels. */
16459   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16460 
16461     /* The 0th argument is a residual literal. */
16462 #if defined(JITTER_DISPATCH_NO_THREADING)
16463 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
16464     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16465 #elif defined (JITTER_REPLICATE)
16466 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
16467 #else
16468 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
16469 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16470 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16471 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16472 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16473 #   define JITTER_ARGF0 JITTER_ARGP0
16474 
16475 
16476 #if defined (JITTER_PROFILE_SAMPLE)
16477   JITTER_PROFILE_SAMPLE_UPDATE
16478      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16479       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16480   /* Force the compiler not move sample-profiling instrumentation
16481      beyond this point; this way the actual user code is timed.
16482      This is still not perfect, as residuals are materialised before
16483      we arrive here, but should be adequate at least for slow VM
16484      instructions. */
16485   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16486 #endif
16487 #if defined (JITTER_PROFILE_COUNT)
16488   /* Notice that, differently from the code above, this
16489      instrumentation code *can* be reordered freely: as long as a
16490      VM instruction is counted, the count increment can be placed
16491      anyehere.  Let GCC move this code and possibly achieve better
16492      throughput by exploiting instruction-level parallelism and
16493      therefore approximate more closely a non-profiled build. */
16494   JITTER_PROFILE_COUNT_UPDATE
16495      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16496       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16497 #endif
16498 
16499 /* User-specified code, instruction-beginning-c part: beginning. */
16500 
16501 /* User-specified code, instruction-beginning-c part: end */
16502 
16503 
16504     /* User code for iutol/nR . */
16505 #line 3855 "../../libpoke/pvm.jitter"
16506 
16507     PVM_CONVOP (UINT, uint32_t, long, int64_t);
16508 
16509     /* End of the user code for iutol/nR . */
16510 
16511 /* User-specified code, instruction-end-c part: beginning. */
16512 
16513 /* User-specified code, instruction-end-c part: end */
16514 
16515     /* Undefine the iutol/nR argument macros so they can't be used
16516        by mistake in the instruction body coming next. */
16517 #   undef JITTER_SLOW_REGISTER_OFFSET0
16518 #   undef JITTER_ARG0
16519 #   undef JITTER_ARGN0
16520 #   undef JITTER_ARGU0
16521 #   undef JITTER_ARGP0
16522 #   undef JITTER_ARGF0
16523 
16524 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16525 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16526 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16527 
16528   }
16529  JITTER_INSTRUCTION_EPILOG_(iutol/nR, iutol__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16530 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16531 
16532   JITTER_INSTRUCTION_PROLOG_(iutolu/nR, iutolu__nR, cold)
16533   {
16534     /* This specialized instruction is not a replacement. */
16535 #   undef JITTER_BRANCH_FAST
16536 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16537 #   undef JITTER_BRANCH_FAST_IF_ZERO
16538 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16539 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16540 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16541 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16542 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16543 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16544 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16545 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16546 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16547 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16548 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16549 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16550 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16551 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16552 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16553 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16554 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16555 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16556 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16557 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16558 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16559 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16560 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16561 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16562 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16563 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16564 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16565 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16566 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16567 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16568 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16569 #   undef JITTER_BRANCH_FAST_IF_AND
16570 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16571 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16572 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16573 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16574 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16575 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16576 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16577 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16578 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16579 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16580 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16581 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16582 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16583 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16584 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16585 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16586 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16587 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16588 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16589 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16590 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16591 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16592 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16593 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16594 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16595 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16596 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16597 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16598 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16599 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       106
16600 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         iutolu/nR
16601 
16602 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME iutolu__nR
16603 
16604   /* The residual arity for this instruction does not depend on fast labels. */
16605   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16606 
16607     /* The 0th argument is a residual literal. */
16608 #if defined(JITTER_DISPATCH_NO_THREADING)
16609 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
16610     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16611 #elif defined (JITTER_REPLICATE)
16612 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
16613 #else
16614 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
16615 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16616 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16617 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16618 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16619 #   define JITTER_ARGF0 JITTER_ARGP0
16620 
16621 
16622 #if defined (JITTER_PROFILE_SAMPLE)
16623   JITTER_PROFILE_SAMPLE_UPDATE
16624      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16625       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16626   /* Force the compiler not move sample-profiling instrumentation
16627      beyond this point; this way the actual user code is timed.
16628      This is still not perfect, as residuals are materialised before
16629      we arrive here, but should be adequate at least for slow VM
16630      instructions. */
16631   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16632 #endif
16633 #if defined (JITTER_PROFILE_COUNT)
16634   /* Notice that, differently from the code above, this
16635      instrumentation code *can* be reordered freely: as long as a
16636      VM instruction is counted, the count increment can be placed
16637      anyehere.  Let GCC move this code and possibly achieve better
16638      throughput by exploiting instruction-level parallelism and
16639      therefore approximate more closely a non-profiled build. */
16640   JITTER_PROFILE_COUNT_UPDATE
16641      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16642       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16643 #endif
16644 
16645 /* User-specified code, instruction-beginning-c part: beginning. */
16646 
16647 /* User-specified code, instruction-beginning-c part: end */
16648 
16649 
16650     /* User code for iutolu/nR . */
16651 #line 3870 "../../libpoke/pvm.jitter"
16652 
16653     PVM_CONVOP (UINT, uint32_t, ulong, uint64_t);
16654 
16655     /* End of the user code for iutolu/nR . */
16656 
16657 /* User-specified code, instruction-end-c part: beginning. */
16658 
16659 /* User-specified code, instruction-end-c part: end */
16660 
16661     /* Undefine the iutolu/nR argument macros so they can't be used
16662        by mistake in the instruction body coming next. */
16663 #   undef JITTER_SLOW_REGISTER_OFFSET0
16664 #   undef JITTER_ARG0
16665 #   undef JITTER_ARGN0
16666 #   undef JITTER_ARGU0
16667 #   undef JITTER_ARGP0
16668 #   undef JITTER_ARGF0
16669 
16670 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16671 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16672 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16673 
16674   }
16675  JITTER_INSTRUCTION_EPILOG_(iutolu/nR, iutolu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16676 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16677 
16678   JITTER_INSTRUCTION_PROLOG_(lei, lei, hot)
16679   {
16680     /* This specialized instruction is not a replacement. */
16681 #   undef JITTER_BRANCH_FAST
16682 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16683 #   undef JITTER_BRANCH_FAST_IF_ZERO
16684 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16685 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16686 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16687 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16688 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16689 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16690 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16691 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16692 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16693 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16694 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16695 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16696 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16697 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16698 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16699 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16700 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16701 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16702 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16703 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16704 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16705 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16706 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16707 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16708 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16709 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16710 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16711 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16712 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16713 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16714 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16715 #   undef JITTER_BRANCH_FAST_IF_AND
16716 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16717 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16718 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16719 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16720 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16721 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16722 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16723 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16724 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16725 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16726 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16727 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16728 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16729 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16730 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16731 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16732 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16733 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16734 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16735 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16736 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16737 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16738 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16739 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16740 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16741 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16742 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16743 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16744 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16745 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       107
16746 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lei
16747 
16748 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lei
16749 
16750   /* The residual arity for this instruction does not depend on fast labels. */
16751   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
16752 
16753 
16754 #if defined (JITTER_PROFILE_SAMPLE)
16755   JITTER_PROFILE_SAMPLE_UPDATE
16756      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16757       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16758   /* Force the compiler not move sample-profiling instrumentation
16759      beyond this point; this way the actual user code is timed.
16760      This is still not perfect, as residuals are materialised before
16761      we arrive here, but should be adequate at least for slow VM
16762      instructions. */
16763   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16764 #endif
16765 #if defined (JITTER_PROFILE_COUNT)
16766   /* Notice that, differently from the code above, this
16767      instrumentation code *can* be reordered freely: as long as a
16768      VM instruction is counted, the count increment can be placed
16769      anyehere.  Let GCC move this code and possibly achieve better
16770      throughput by exploiting instruction-level parallelism and
16771      therefore approximate more closely a non-profiled build. */
16772   JITTER_PROFILE_COUNT_UPDATE
16773      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16774       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16775 #endif
16776 
16777 /* User-specified code, instruction-beginning-c part: beginning. */
16778 
16779 /* User-specified code, instruction-beginning-c part: end */
16780 
16781 
16782     /* User code for lei . */
16783 #line 2897 "../../libpoke/pvm.jitter"
16784 
16785      PVM_BOOL_BINOP (INT, <=);
16786 
16787     /* End of the user code for lei . */
16788 
16789 /* User-specified code, instruction-end-c part: beginning. */
16790 
16791 /* User-specified code, instruction-end-c part: end */
16792 
16793     /* Undefine the lei argument macros so they can't be used
16794        by mistake in the instruction body coming next. */
16795 
16796 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16797 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16798 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16799 
16800   }
16801  JITTER_INSTRUCTION_EPILOG_(lei, lei, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16802 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16803 
16804   JITTER_INSTRUCTION_PROLOG_(leiu, leiu, hot)
16805   {
16806     /* This specialized instruction is not a replacement. */
16807 #   undef JITTER_BRANCH_FAST
16808 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16809 #   undef JITTER_BRANCH_FAST_IF_ZERO
16810 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16811 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16812 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16813 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16814 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16815 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16816 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16817 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16818 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16819 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16820 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16821 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16822 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16823 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16824 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16825 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16826 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16827 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16828 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16829 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16830 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16831 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16832 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16833 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16834 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16835 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16836 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16837 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16838 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16839 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16840 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16841 #   undef JITTER_BRANCH_FAST_IF_AND
16842 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16843 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16844 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16845 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16846 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16847 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16848 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16849 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16850 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16851 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16852 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16853 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16854 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16855 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16856 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16857 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16858 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16859 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16860 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16861 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16862 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16863 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16864 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16865 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16866 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16867 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16868 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16869 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16870 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16871 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       108
16872 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         leiu
16873 
16874 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME leiu
16875 
16876   /* The residual arity for this instruction does not depend on fast labels. */
16877   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
16878 
16879 
16880 #if defined (JITTER_PROFILE_SAMPLE)
16881   JITTER_PROFILE_SAMPLE_UPDATE
16882      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16883       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16884   /* Force the compiler not move sample-profiling instrumentation
16885      beyond this point; this way the actual user code is timed.
16886      This is still not perfect, as residuals are materialised before
16887      we arrive here, but should be adequate at least for slow VM
16888      instructions. */
16889   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16890 #endif
16891 #if defined (JITTER_PROFILE_COUNT)
16892   /* Notice that, differently from the code above, this
16893      instrumentation code *can* be reordered freely: as long as a
16894      VM instruction is counted, the count increment can be placed
16895      anyehere.  Let GCC move this code and possibly achieve better
16896      throughput by exploiting instruction-level parallelism and
16897      therefore approximate more closely a non-profiled build. */
16898   JITTER_PROFILE_COUNT_UPDATE
16899      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16900       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16901 #endif
16902 
16903 /* User-specified code, instruction-beginning-c part: beginning. */
16904 
16905 /* User-specified code, instruction-beginning-c part: end */
16906 
16907 
16908     /* User code for leiu . */
16909 #line 2910 "../../libpoke/pvm.jitter"
16910 
16911      PVM_BOOL_BINOP (UINT, <=);
16912 
16913     /* End of the user code for leiu . */
16914 
16915 /* User-specified code, instruction-end-c part: beginning. */
16916 
16917 /* User-specified code, instruction-end-c part: end */
16918 
16919     /* Undefine the leiu argument macros so they can't be used
16920        by mistake in the instruction body coming next. */
16921 
16922 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16923 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16924 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16925 
16926   }
16927  JITTER_INSTRUCTION_EPILOG_(leiu, leiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16928 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16929 
16930   JITTER_INSTRUCTION_PROLOG_(lel, lel, hot)
16931   {
16932     /* This specialized instruction is not a replacement. */
16933 #   undef JITTER_BRANCH_FAST
16934 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16935 #   undef JITTER_BRANCH_FAST_IF_ZERO
16936 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16937 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16938 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16939 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16940 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16941 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16942 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16943 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16944 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16945 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16946 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16947 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16948 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16949 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16950 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16951 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16952 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16953 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16954 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16955 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16956 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16957 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16958 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16959 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16960 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16961 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16962 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16963 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16964 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16965 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16966 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16967 #   undef JITTER_BRANCH_FAST_IF_AND
16968 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16969 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16970 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16971 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16972 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16973 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16974 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16975 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16976 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16977 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16978 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16979 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16980 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16981 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16982 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16983 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16984 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16985 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16986 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16987 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16988 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16989 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16990 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16991 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16992 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16993 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16994 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16995 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16996 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16997 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       109
16998 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lel
16999 
17000 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lel
17001 
17002   /* The residual arity for this instruction does not depend on fast labels. */
17003   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17004 
17005 
17006 #if defined (JITTER_PROFILE_SAMPLE)
17007   JITTER_PROFILE_SAMPLE_UPDATE
17008      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17009       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17010   /* Force the compiler not move sample-profiling instrumentation
17011      beyond this point; this way the actual user code is timed.
17012      This is still not perfect, as residuals are materialised before
17013      we arrive here, but should be adequate at least for slow VM
17014      instructions. */
17015   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17016 #endif
17017 #if defined (JITTER_PROFILE_COUNT)
17018   /* Notice that, differently from the code above, this
17019      instrumentation code *can* be reordered freely: as long as a
17020      VM instruction is counted, the count increment can be placed
17021      anyehere.  Let GCC move this code and possibly achieve better
17022      throughput by exploiting instruction-level parallelism and
17023      therefore approximate more closely a non-profiled build. */
17024   JITTER_PROFILE_COUNT_UPDATE
17025      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17026       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17027 #endif
17028 
17029 /* User-specified code, instruction-beginning-c part: beginning. */
17030 
17031 /* User-specified code, instruction-beginning-c part: end */
17032 
17033 
17034     /* User code for lel . */
17035 #line 2923 "../../libpoke/pvm.jitter"
17036 
17037      PVM_BOOL_BINOP (LONG, <=);
17038 
17039     /* End of the user code for lel . */
17040 
17041 /* User-specified code, instruction-end-c part: beginning. */
17042 
17043 /* User-specified code, instruction-end-c part: end */
17044 
17045     /* Undefine the lel argument macros so they can't be used
17046        by mistake in the instruction body coming next. */
17047 
17048 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17049 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17050 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17051 
17052   }
17053  JITTER_INSTRUCTION_EPILOG_(lel, lel, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17054 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17055 
17056   JITTER_INSTRUCTION_PROLOG_(lelu, lelu, hot)
17057   {
17058     /* This specialized instruction is not a replacement. */
17059 #   undef JITTER_BRANCH_FAST
17060 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17061 #   undef JITTER_BRANCH_FAST_IF_ZERO
17062 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17063 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17064 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17065 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17066 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17067 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17068 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17069 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17070 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17071 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17072 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17073 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17074 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17075 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17076 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17077 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17078 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17079 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17080 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17081 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17082 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17083 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17084 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17085 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17086 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17087 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17088 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17089 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17090 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17091 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17092 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17093 #   undef JITTER_BRANCH_FAST_IF_AND
17094 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17095 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17096 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17097 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17098 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17099 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17100 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17101 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17102 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17103 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17104 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17105 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17106 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17107 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17108 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17109 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17110 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17111 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17112 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17113 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17114 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17115 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17116 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17117 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17118 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17119 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17120 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17121 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17122 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17123 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       110
17124 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lelu
17125 
17126 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lelu
17127 
17128   /* The residual arity for this instruction does not depend on fast labels. */
17129   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17130 
17131 
17132 #if defined (JITTER_PROFILE_SAMPLE)
17133   JITTER_PROFILE_SAMPLE_UPDATE
17134      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17135       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17136   /* Force the compiler not move sample-profiling instrumentation
17137      beyond this point; this way the actual user code is timed.
17138      This is still not perfect, as residuals are materialised before
17139      we arrive here, but should be adequate at least for slow VM
17140      instructions. */
17141   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17142 #endif
17143 #if defined (JITTER_PROFILE_COUNT)
17144   /* Notice that, differently from the code above, this
17145      instrumentation code *can* be reordered freely: as long as a
17146      VM instruction is counted, the count increment can be placed
17147      anyehere.  Let GCC move this code and possibly achieve better
17148      throughput by exploiting instruction-level parallelism and
17149      therefore approximate more closely a non-profiled build. */
17150   JITTER_PROFILE_COUNT_UPDATE
17151      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17152       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17153 #endif
17154 
17155 /* User-specified code, instruction-beginning-c part: beginning. */
17156 
17157 /* User-specified code, instruction-beginning-c part: end */
17158 
17159 
17160     /* User code for lelu . */
17161 #line 2936 "../../libpoke/pvm.jitter"
17162 
17163      PVM_BOOL_BINOP (ULONG, <=);
17164 
17165     /* End of the user code for lelu . */
17166 
17167 /* User-specified code, instruction-end-c part: beginning. */
17168 
17169 /* User-specified code, instruction-end-c part: end */
17170 
17171     /* Undefine the lelu argument macros so they can't be used
17172        by mistake in the instruction body coming next. */
17173 
17174 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17175 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17176 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17177 
17178   }
17179  JITTER_INSTRUCTION_EPILOG_(lelu, lelu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17180 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17181 
17182   JITTER_INSTRUCTION_PROLOG_(les, les, hot)
17183   {
17184     /* This specialized instruction is not a replacement. */
17185 #   undef JITTER_BRANCH_FAST
17186 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17187 #   undef JITTER_BRANCH_FAST_IF_ZERO
17188 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17189 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17190 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17191 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17192 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17193 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17194 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17195 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17196 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17197 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17198 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17199 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17200 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17201 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17202 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17203 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17204 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17205 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17206 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17207 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17208 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17209 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17210 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17211 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17212 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17213 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17214 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17215 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17216 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17217 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17218 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17219 #   undef JITTER_BRANCH_FAST_IF_AND
17220 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17221 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17222 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17223 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17224 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17225 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17226 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17227 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17228 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17229 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17230 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17231 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17232 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17233 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17234 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17235 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17236 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17237 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17238 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17239 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17240 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17241 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17242 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17243 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17244 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17245 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17246 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17247 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17248 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17249 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       111
17250 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         les
17251 
17252 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME les
17253 
17254   /* The residual arity for this instruction does not depend on fast labels. */
17255   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17256 
17257 
17258 #if defined (JITTER_PROFILE_SAMPLE)
17259   JITTER_PROFILE_SAMPLE_UPDATE
17260      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17261       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17262   /* Force the compiler not move sample-profiling instrumentation
17263      beyond this point; this way the actual user code is timed.
17264      This is still not perfect, as residuals are materialised before
17265      we arrive here, but should be adequate at least for slow VM
17266      instructions. */
17267   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17268 #endif
17269 #if defined (JITTER_PROFILE_COUNT)
17270   /* Notice that, differently from the code above, this
17271      instrumentation code *can* be reordered freely: as long as a
17272      VM instruction is counted, the count increment can be placed
17273      anyehere.  Let GCC move this code and possibly achieve better
17274      throughput by exploiting instruction-level parallelism and
17275      therefore approximate more closely a non-profiled build. */
17276   JITTER_PROFILE_COUNT_UPDATE
17277      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17278       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17279 #endif
17280 
17281 /* User-specified code, instruction-beginning-c part: beginning. */
17282 
17283 /* User-specified code, instruction-beginning-c part: end */
17284 
17285 
17286     /* User code for les . */
17287 #line 3101 "../../libpoke/pvm.jitter"
17288 
17289     pvm_val res = PVM_MAKE_INT (strcmp (PVM_VAL_STR (JITTER_UNDER_TOP_STACK ()),
17290                                         PVM_VAL_STR (JITTER_TOP_STACK ())) <= 0, 32);
17291     JITTER_PUSH_STACK (res);
17292 
17293     /* End of the user code for les . */
17294 
17295 /* User-specified code, instruction-end-c part: beginning. */
17296 
17297 /* User-specified code, instruction-end-c part: end */
17298 
17299     /* Undefine the les argument macros so they can't be used
17300        by mistake in the instruction body coming next. */
17301 
17302 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17303 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17304 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17305 
17306   }
17307  JITTER_INSTRUCTION_EPILOG_(les, les, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17308 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17309 
17310   JITTER_INSTRUCTION_PROLOG_(lti, lti, hot)
17311   {
17312     /* This specialized instruction is not a replacement. */
17313 #   undef JITTER_BRANCH_FAST
17314 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17315 #   undef JITTER_BRANCH_FAST_IF_ZERO
17316 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17317 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17318 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17319 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17320 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17321 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17322 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17323 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17324 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17325 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17326 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17327 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17328 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17329 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17330 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17331 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17332 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17333 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17334 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17335 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17336 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17337 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17338 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17339 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17340 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17341 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17342 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17343 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17344 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17345 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17346 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17347 #   undef JITTER_BRANCH_FAST_IF_AND
17348 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17349 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17350 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17351 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17352 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17353 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17354 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17355 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17356 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17357 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17358 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17359 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17360 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17361 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17362 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17363 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17364 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17365 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17366 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17367 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17368 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17369 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17370 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17371 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17372 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17373 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17374 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17375 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17376 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17377 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       112
17378 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lti
17379 
17380 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lti
17381 
17382   /* The residual arity for this instruction does not depend on fast labels. */
17383   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17384 
17385 
17386 #if defined (JITTER_PROFILE_SAMPLE)
17387   JITTER_PROFILE_SAMPLE_UPDATE
17388      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17389       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17390   /* Force the compiler not move sample-profiling instrumentation
17391      beyond this point; this way the actual user code is timed.
17392      This is still not perfect, as residuals are materialised before
17393      we arrive here, but should be adequate at least for slow VM
17394      instructions. */
17395   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17396 #endif
17397 #if defined (JITTER_PROFILE_COUNT)
17398   /* Notice that, differently from the code above, this
17399      instrumentation code *can* be reordered freely: as long as a
17400      VM instruction is counted, the count increment can be placed
17401      anyehere.  Let GCC move this code and possibly achieve better
17402      throughput by exploiting instruction-level parallelism and
17403      therefore approximate more closely a non-profiled build. */
17404   JITTER_PROFILE_COUNT_UPDATE
17405      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17406       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17407 #endif
17408 
17409 /* User-specified code, instruction-beginning-c part: beginning. */
17410 
17411 /* User-specified code, instruction-beginning-c part: end */
17412 
17413 
17414     /* User code for lti . */
17415 #line 2845 "../../libpoke/pvm.jitter"
17416 
17417      PVM_BOOL_BINOP (INT, <);
17418 
17419     /* End of the user code for lti . */
17420 
17421 /* User-specified code, instruction-end-c part: beginning. */
17422 
17423 /* User-specified code, instruction-end-c part: end */
17424 
17425     /* Undefine the lti argument macros so they can't be used
17426        by mistake in the instruction body coming next. */
17427 
17428 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17429 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17430 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17431 
17432   }
17433  JITTER_INSTRUCTION_EPILOG_(lti, lti, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17434 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17435 
17436   JITTER_INSTRUCTION_PROLOG_(ltiu, ltiu, hot)
17437   {
17438     /* This specialized instruction is not a replacement. */
17439 #   undef JITTER_BRANCH_FAST
17440 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17441 #   undef JITTER_BRANCH_FAST_IF_ZERO
17442 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17443 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17444 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17445 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17446 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17447 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17448 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17449 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17450 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17451 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17452 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17453 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17454 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17455 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17456 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17457 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17458 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17459 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17460 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17461 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17462 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17463 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17464 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17465 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17466 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17467 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17468 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17469 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17470 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17471 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17472 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17473 #   undef JITTER_BRANCH_FAST_IF_AND
17474 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17475 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17476 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17477 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17478 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17479 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17480 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17481 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17482 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17483 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17484 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17485 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17486 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17487 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17488 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17489 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17490 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17491 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17492 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17493 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17494 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17495 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17496 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17497 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17498 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17499 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17500 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17501 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17502 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17503 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       113
17504 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ltiu
17505 
17506 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ltiu
17507 
17508   /* The residual arity for this instruction does not depend on fast labels. */
17509   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17510 
17511 
17512 #if defined (JITTER_PROFILE_SAMPLE)
17513   JITTER_PROFILE_SAMPLE_UPDATE
17514      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17515       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17516   /* Force the compiler not move sample-profiling instrumentation
17517      beyond this point; this way the actual user code is timed.
17518      This is still not perfect, as residuals are materialised before
17519      we arrive here, but should be adequate at least for slow VM
17520      instructions. */
17521   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17522 #endif
17523 #if defined (JITTER_PROFILE_COUNT)
17524   /* Notice that, differently from the code above, this
17525      instrumentation code *can* be reordered freely: as long as a
17526      VM instruction is counted, the count increment can be placed
17527      anyehere.  Let GCC move this code and possibly achieve better
17528      throughput by exploiting instruction-level parallelism and
17529      therefore approximate more closely a non-profiled build. */
17530   JITTER_PROFILE_COUNT_UPDATE
17531      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17532       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17533 #endif
17534 
17535 /* User-specified code, instruction-beginning-c part: beginning. */
17536 
17537 /* User-specified code, instruction-beginning-c part: end */
17538 
17539 
17540     /* User code for ltiu . */
17541 #line 2858 "../../libpoke/pvm.jitter"
17542 
17543      PVM_BOOL_BINOP (UINT, <);
17544 
17545     /* End of the user code for ltiu . */
17546 
17547 /* User-specified code, instruction-end-c part: beginning. */
17548 
17549 /* User-specified code, instruction-end-c part: end */
17550 
17551     /* Undefine the ltiu argument macros so they can't be used
17552        by mistake in the instruction body coming next. */
17553 
17554 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17555 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17556 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17557 
17558   }
17559  JITTER_INSTRUCTION_EPILOG_(ltiu, ltiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17560 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17561 
17562   JITTER_INSTRUCTION_PROLOG_(ltl, ltl, hot)
17563   {
17564     /* This specialized instruction is not a replacement. */
17565 #   undef JITTER_BRANCH_FAST
17566 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17567 #   undef JITTER_BRANCH_FAST_IF_ZERO
17568 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17569 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17570 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17571 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17572 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17573 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17574 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17575 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17576 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17577 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17578 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17579 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17580 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17581 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17582 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17583 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17584 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17585 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17586 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17587 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17588 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17589 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17590 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17591 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17592 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17593 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17594 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17595 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17596 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17597 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17598 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17599 #   undef JITTER_BRANCH_FAST_IF_AND
17600 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17601 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17602 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17603 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17604 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17605 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17606 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17607 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17608 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17609 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17610 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17611 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17612 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17613 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17614 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17615 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17616 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17617 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17618 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17619 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17620 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17621 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17622 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17623 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17624 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17625 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17626 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17627 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17628 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17629 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       114
17630 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ltl
17631 
17632 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ltl
17633 
17634   /* The residual arity for this instruction does not depend on fast labels. */
17635   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17636 
17637 
17638 #if defined (JITTER_PROFILE_SAMPLE)
17639   JITTER_PROFILE_SAMPLE_UPDATE
17640      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17641       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17642   /* Force the compiler not move sample-profiling instrumentation
17643      beyond this point; this way the actual user code is timed.
17644      This is still not perfect, as residuals are materialised before
17645      we arrive here, but should be adequate at least for slow VM
17646      instructions. */
17647   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17648 #endif
17649 #if defined (JITTER_PROFILE_COUNT)
17650   /* Notice that, differently from the code above, this
17651      instrumentation code *can* be reordered freely: as long as a
17652      VM instruction is counted, the count increment can be placed
17653      anyehere.  Let GCC move this code and possibly achieve better
17654      throughput by exploiting instruction-level parallelism and
17655      therefore approximate more closely a non-profiled build. */
17656   JITTER_PROFILE_COUNT_UPDATE
17657      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17658       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17659 #endif
17660 
17661 /* User-specified code, instruction-beginning-c part: beginning. */
17662 
17663 /* User-specified code, instruction-beginning-c part: end */
17664 
17665 
17666     /* User code for ltl . */
17667 #line 2871 "../../libpoke/pvm.jitter"
17668 
17669      PVM_BOOL_BINOP (LONG, <);
17670 
17671     /* End of the user code for ltl . */
17672 
17673 /* User-specified code, instruction-end-c part: beginning. */
17674 
17675 /* User-specified code, instruction-end-c part: end */
17676 
17677     /* Undefine the ltl argument macros so they can't be used
17678        by mistake in the instruction body coming next. */
17679 
17680 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17681 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17682 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17683 
17684   }
17685  JITTER_INSTRUCTION_EPILOG_(ltl, ltl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17686 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17687 
17688   JITTER_INSTRUCTION_PROLOG_(ltlu, ltlu, hot)
17689   {
17690     /* This specialized instruction is not a replacement. */
17691 #   undef JITTER_BRANCH_FAST
17692 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17693 #   undef JITTER_BRANCH_FAST_IF_ZERO
17694 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17695 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17696 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17697 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17698 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17699 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17700 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17701 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17702 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17703 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17704 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17705 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17706 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17707 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17708 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17709 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17710 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17711 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17712 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17713 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17714 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17715 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17716 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17717 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17718 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17719 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17720 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17721 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17722 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17723 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17724 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17725 #   undef JITTER_BRANCH_FAST_IF_AND
17726 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17727 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17728 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17729 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17730 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17731 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17732 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17733 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17734 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17735 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17736 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17737 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17738 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17739 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17740 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17741 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17742 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17743 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17744 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17745 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17746 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17747 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17748 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17749 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17750 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17751 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17752 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17753 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17754 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17755 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       115
17756 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ltlu
17757 
17758 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ltlu
17759 
17760   /* The residual arity for this instruction does not depend on fast labels. */
17761   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17762 
17763 
17764 #if defined (JITTER_PROFILE_SAMPLE)
17765   JITTER_PROFILE_SAMPLE_UPDATE
17766      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17767       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17768   /* Force the compiler not move sample-profiling instrumentation
17769      beyond this point; this way the actual user code is timed.
17770      This is still not perfect, as residuals are materialised before
17771      we arrive here, but should be adequate at least for slow VM
17772      instructions. */
17773   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17774 #endif
17775 #if defined (JITTER_PROFILE_COUNT)
17776   /* Notice that, differently from the code above, this
17777      instrumentation code *can* be reordered freely: as long as a
17778      VM instruction is counted, the count increment can be placed
17779      anyehere.  Let GCC move this code and possibly achieve better
17780      throughput by exploiting instruction-level parallelism and
17781      therefore approximate more closely a non-profiled build. */
17782   JITTER_PROFILE_COUNT_UPDATE
17783      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17784       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17785 #endif
17786 
17787 /* User-specified code, instruction-beginning-c part: beginning. */
17788 
17789 /* User-specified code, instruction-beginning-c part: end */
17790 
17791 
17792     /* User code for ltlu . */
17793 #line 2884 "../../libpoke/pvm.jitter"
17794 
17795      PVM_BOOL_BINOP (ULONG, <);
17796 
17797     /* End of the user code for ltlu . */
17798 
17799 /* User-specified code, instruction-end-c part: beginning. */
17800 
17801 /* User-specified code, instruction-end-c part: end */
17802 
17803     /* Undefine the ltlu argument macros so they can't be used
17804        by mistake in the instruction body coming next. */
17805 
17806 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17807 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17808 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17809 
17810   }
17811  JITTER_INSTRUCTION_EPILOG_(ltlu, ltlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17812 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17813 
17814   JITTER_INSTRUCTION_PROLOG_(ltoi/nR, ltoi__nR, cold)
17815   {
17816     /* This specialized instruction is not a replacement. */
17817 #   undef JITTER_BRANCH_FAST
17818 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17819 #   undef JITTER_BRANCH_FAST_IF_ZERO
17820 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17821 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17822 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17823 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17824 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17825 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17826 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17827 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17828 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17829 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17830 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17831 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17832 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17833 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17834 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17835 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17836 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17837 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17838 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17839 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17840 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17841 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17842 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17843 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17844 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17845 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17846 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17847 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17848 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17849 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17850 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17851 #   undef JITTER_BRANCH_FAST_IF_AND
17852 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17853 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17854 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17855 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17856 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17857 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17858 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17859 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17860 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17861 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17862 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17863 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17864 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17865 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17866 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17867 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17868 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17869 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17870 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17871 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17872 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17873 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17874 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17875 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17876 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17877 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17878 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17879 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17880 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17881 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       116
17882 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ltoi/nR
17883 
17884 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ltoi__nR
17885 
17886   /* The residual arity for this instruction does not depend on fast labels. */
17887   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
17888 
17889     /* The 0th argument is a residual literal. */
17890 #if defined(JITTER_DISPATCH_NO_THREADING)
17891 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
17892     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
17893 #elif defined (JITTER_REPLICATE)
17894 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
17895 #else
17896 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
17897 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
17898 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
17899 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
17900 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
17901 #   define JITTER_ARGF0 JITTER_ARGP0
17902 
17903 
17904 #if defined (JITTER_PROFILE_SAMPLE)
17905   JITTER_PROFILE_SAMPLE_UPDATE
17906      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17907       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17908   /* Force the compiler not move sample-profiling instrumentation
17909      beyond this point; this way the actual user code is timed.
17910      This is still not perfect, as residuals are materialised before
17911      we arrive here, but should be adequate at least for slow VM
17912      instructions. */
17913   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17914 #endif
17915 #if defined (JITTER_PROFILE_COUNT)
17916   /* Notice that, differently from the code above, this
17917      instrumentation code *can* be reordered freely: as long as a
17918      VM instruction is counted, the count increment can be placed
17919      anyehere.  Let GCC move this code and possibly achieve better
17920      throughput by exploiting instruction-level parallelism and
17921      therefore approximate more closely a non-profiled build. */
17922   JITTER_PROFILE_COUNT_UPDATE
17923      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17924       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17925 #endif
17926 
17927 /* User-specified code, instruction-beginning-c part: beginning. */
17928 
17929 /* User-specified code, instruction-beginning-c part: end */
17930 
17931 
17932     /* User code for ltoi/nR . */
17933 #line 3885 "../../libpoke/pvm.jitter"
17934 
17935     PVM_CONVOP (LONG, int64_t, int, int32_t);
17936 
17937     /* End of the user code for ltoi/nR . */
17938 
17939 /* User-specified code, instruction-end-c part: beginning. */
17940 
17941 /* User-specified code, instruction-end-c part: end */
17942 
17943     /* Undefine the ltoi/nR argument macros so they can't be used
17944        by mistake in the instruction body coming next. */
17945 #   undef JITTER_SLOW_REGISTER_OFFSET0
17946 #   undef JITTER_ARG0
17947 #   undef JITTER_ARGN0
17948 #   undef JITTER_ARGU0
17949 #   undef JITTER_ARGP0
17950 #   undef JITTER_ARGF0
17951 
17952 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17953 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17954 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17955 
17956   }
17957  JITTER_INSTRUCTION_EPILOG_(ltoi/nR, ltoi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17958 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17959 
17960   JITTER_INSTRUCTION_PROLOG_(ltoiu/nR, ltoiu__nR, cold)
17961   {
17962     /* This specialized instruction is not a replacement. */
17963 #   undef JITTER_BRANCH_FAST
17964 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17965 #   undef JITTER_BRANCH_FAST_IF_ZERO
17966 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17967 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17968 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17969 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17970 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17971 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17972 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17973 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17974 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17975 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17976 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17977 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17978 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17979 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17980 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17981 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17982 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17983 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17984 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17985 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17986 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17987 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17988 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17989 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17990 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17991 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17992 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17993 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17994 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17995 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17996 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17997 #   undef JITTER_BRANCH_FAST_IF_AND
17998 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17999 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18000 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18001 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18002 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18003 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18004 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18005 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18006 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18007 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18008 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18009 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18010 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18011 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18012 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18013 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18014 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18015 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18016 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18017 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18018 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18019 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18020 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18021 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18022 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18023 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18024 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18025 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18026 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18027 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       117
18028 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ltoiu/nR
18029 
18030 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ltoiu__nR
18031 
18032   /* The residual arity for this instruction does not depend on fast labels. */
18033   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18034 
18035     /* The 0th argument is a residual literal. */
18036 #if defined(JITTER_DISPATCH_NO_THREADING)
18037 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18038     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18039 #elif defined (JITTER_REPLICATE)
18040 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18041 #else
18042 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18043 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18044 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18045 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18046 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18047 #   define JITTER_ARGF0 JITTER_ARGP0
18048 
18049 
18050 #if defined (JITTER_PROFILE_SAMPLE)
18051   JITTER_PROFILE_SAMPLE_UPDATE
18052      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18053       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18054   /* Force the compiler not move sample-profiling instrumentation
18055      beyond this point; this way the actual user code is timed.
18056      This is still not perfect, as residuals are materialised before
18057      we arrive here, but should be adequate at least for slow VM
18058      instructions. */
18059   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18060 #endif
18061 #if defined (JITTER_PROFILE_COUNT)
18062   /* Notice that, differently from the code above, this
18063      instrumentation code *can* be reordered freely: as long as a
18064      VM instruction is counted, the count increment can be placed
18065      anyehere.  Let GCC move this code and possibly achieve better
18066      throughput by exploiting instruction-level parallelism and
18067      therefore approximate more closely a non-profiled build. */
18068   JITTER_PROFILE_COUNT_UPDATE
18069      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18070       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18071 #endif
18072 
18073 /* User-specified code, instruction-beginning-c part: beginning. */
18074 
18075 /* User-specified code, instruction-beginning-c part: end */
18076 
18077 
18078     /* User code for ltoiu/nR . */
18079 #line 3900 "../../libpoke/pvm.jitter"
18080 
18081     PVM_CONVOP (LONG, int64_t, uint, uint32_t);
18082 
18083     /* End of the user code for ltoiu/nR . */
18084 
18085 /* User-specified code, instruction-end-c part: beginning. */
18086 
18087 /* User-specified code, instruction-end-c part: end */
18088 
18089     /* Undefine the ltoiu/nR argument macros so they can't be used
18090        by mistake in the instruction body coming next. */
18091 #   undef JITTER_SLOW_REGISTER_OFFSET0
18092 #   undef JITTER_ARG0
18093 #   undef JITTER_ARGN0
18094 #   undef JITTER_ARGU0
18095 #   undef JITTER_ARGP0
18096 #   undef JITTER_ARGF0
18097 
18098 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18099 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18100 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18101 
18102   }
18103  JITTER_INSTRUCTION_EPILOG_(ltoiu/nR, ltoiu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18104 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18105 
18106   JITTER_INSTRUCTION_PROLOG_(ltol/nR, ltol__nR, cold)
18107   {
18108     /* This specialized instruction is not a replacement. */
18109 #   undef JITTER_BRANCH_FAST
18110 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18111 #   undef JITTER_BRANCH_FAST_IF_ZERO
18112 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18113 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18114 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18115 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18116 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18117 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18118 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18119 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18120 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18121 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18122 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18123 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18124 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18125 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18126 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18127 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18128 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18129 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18130 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18131 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18132 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18133 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18134 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18135 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18136 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18137 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18138 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18139 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18140 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18141 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18142 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18143 #   undef JITTER_BRANCH_FAST_IF_AND
18144 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18145 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18146 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18147 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18148 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18149 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18150 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18151 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18152 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18153 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18154 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18155 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18156 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18157 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18158 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18159 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18160 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18161 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18162 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18163 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18164 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18165 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18166 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18167 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18168 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18169 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18170 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18171 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18172 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18173 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       118
18174 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ltol/nR
18175 
18176 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ltol__nR
18177 
18178   /* The residual arity for this instruction does not depend on fast labels. */
18179   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18180 
18181     /* The 0th argument is a residual literal. */
18182 #if defined(JITTER_DISPATCH_NO_THREADING)
18183 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18184     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18185 #elif defined (JITTER_REPLICATE)
18186 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18187 #else
18188 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18189 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18190 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18191 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18192 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18193 #   define JITTER_ARGF0 JITTER_ARGP0
18194 
18195 
18196 #if defined (JITTER_PROFILE_SAMPLE)
18197   JITTER_PROFILE_SAMPLE_UPDATE
18198      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18199       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18200   /* Force the compiler not move sample-profiling instrumentation
18201      beyond this point; this way the actual user code is timed.
18202      This is still not perfect, as residuals are materialised before
18203      we arrive here, but should be adequate at least for slow VM
18204      instructions. */
18205   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18206 #endif
18207 #if defined (JITTER_PROFILE_COUNT)
18208   /* Notice that, differently from the code above, this
18209      instrumentation code *can* be reordered freely: as long as a
18210      VM instruction is counted, the count increment can be placed
18211      anyehere.  Let GCC move this code and possibly achieve better
18212      throughput by exploiting instruction-level parallelism and
18213      therefore approximate more closely a non-profiled build. */
18214   JITTER_PROFILE_COUNT_UPDATE
18215      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18216       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18217 #endif
18218 
18219 /* User-specified code, instruction-beginning-c part: beginning. */
18220 
18221 /* User-specified code, instruction-beginning-c part: end */
18222 
18223 
18224     /* User code for ltol/nR . */
18225 #line 3915 "../../libpoke/pvm.jitter"
18226 
18227     PVM_CONVOP (LONG, int64_t, long, int64_t);
18228 
18229     /* End of the user code for ltol/nR . */
18230 
18231 /* User-specified code, instruction-end-c part: beginning. */
18232 
18233 /* User-specified code, instruction-end-c part: end */
18234 
18235     /* Undefine the ltol/nR argument macros so they can't be used
18236        by mistake in the instruction body coming next. */
18237 #   undef JITTER_SLOW_REGISTER_OFFSET0
18238 #   undef JITTER_ARG0
18239 #   undef JITTER_ARGN0
18240 #   undef JITTER_ARGU0
18241 #   undef JITTER_ARGP0
18242 #   undef JITTER_ARGF0
18243 
18244 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18245 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18246 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18247 
18248   }
18249  JITTER_INSTRUCTION_EPILOG_(ltol/nR, ltol__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18250 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18251 
18252   JITTER_INSTRUCTION_PROLOG_(ltolu/nR, ltolu__nR, cold)
18253   {
18254     /* This specialized instruction is not a replacement. */
18255 #   undef JITTER_BRANCH_FAST
18256 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18257 #   undef JITTER_BRANCH_FAST_IF_ZERO
18258 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18259 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18260 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18261 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18262 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18263 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18264 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18265 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18266 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18267 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18268 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18269 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18270 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18271 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18272 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18273 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18274 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18275 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18276 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18277 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18278 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18279 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18280 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18281 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18282 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18283 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18284 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18285 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18286 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18287 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18288 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18289 #   undef JITTER_BRANCH_FAST_IF_AND
18290 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18291 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18292 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18293 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18294 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18295 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18296 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18297 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18298 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18299 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18300 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18301 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18302 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18303 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18304 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18305 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18306 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18307 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18308 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18309 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18310 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18311 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18312 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18313 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18314 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18315 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18316 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18317 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18318 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18319 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       119
18320 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ltolu/nR
18321 
18322 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ltolu__nR
18323 
18324   /* The residual arity for this instruction does not depend on fast labels. */
18325   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18326 
18327     /* The 0th argument is a residual literal. */
18328 #if defined(JITTER_DISPATCH_NO_THREADING)
18329 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18330     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18331 #elif defined (JITTER_REPLICATE)
18332 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18333 #else
18334 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18335 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18336 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18337 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18338 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18339 #   define JITTER_ARGF0 JITTER_ARGP0
18340 
18341 
18342 #if defined (JITTER_PROFILE_SAMPLE)
18343   JITTER_PROFILE_SAMPLE_UPDATE
18344      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18345       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18346   /* Force the compiler not move sample-profiling instrumentation
18347      beyond this point; this way the actual user code is timed.
18348      This is still not perfect, as residuals are materialised before
18349      we arrive here, but should be adequate at least for slow VM
18350      instructions. */
18351   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18352 #endif
18353 #if defined (JITTER_PROFILE_COUNT)
18354   /* Notice that, differently from the code above, this
18355      instrumentation code *can* be reordered freely: as long as a
18356      VM instruction is counted, the count increment can be placed
18357      anyehere.  Let GCC move this code and possibly achieve better
18358      throughput by exploiting instruction-level parallelism and
18359      therefore approximate more closely a non-profiled build. */
18360   JITTER_PROFILE_COUNT_UPDATE
18361      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18362       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18363 #endif
18364 
18365 /* User-specified code, instruction-beginning-c part: beginning. */
18366 
18367 /* User-specified code, instruction-beginning-c part: end */
18368 
18369 
18370     /* User code for ltolu/nR . */
18371 #line 3930 "../../libpoke/pvm.jitter"
18372 
18373     PVM_CONVOP (LONG, int64_t, ulong, uint64_t);
18374 
18375     /* End of the user code for ltolu/nR . */
18376 
18377 /* User-specified code, instruction-end-c part: beginning. */
18378 
18379 /* User-specified code, instruction-end-c part: end */
18380 
18381     /* Undefine the ltolu/nR argument macros so they can't be used
18382        by mistake in the instruction body coming next. */
18383 #   undef JITTER_SLOW_REGISTER_OFFSET0
18384 #   undef JITTER_ARG0
18385 #   undef JITTER_ARGN0
18386 #   undef JITTER_ARGU0
18387 #   undef JITTER_ARGP0
18388 #   undef JITTER_ARGF0
18389 
18390 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18391 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18392 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18393 
18394   }
18395  JITTER_INSTRUCTION_EPILOG_(ltolu/nR, ltolu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18396 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18397 
18398   JITTER_INSTRUCTION_PROLOG_(lts, lts, hot)
18399   {
18400     /* This specialized instruction is not a replacement. */
18401 #   undef JITTER_BRANCH_FAST
18402 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18403 #   undef JITTER_BRANCH_FAST_IF_ZERO
18404 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18405 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18406 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18407 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18408 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18409 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18410 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18411 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18412 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18413 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18414 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18415 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18416 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18417 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18418 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18419 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18420 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18421 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18422 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18423 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18424 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18425 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18426 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18427 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18428 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18429 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18430 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18431 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18432 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18433 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18434 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18435 #   undef JITTER_BRANCH_FAST_IF_AND
18436 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18437 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18438 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18439 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18440 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18441 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18442 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18443 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18444 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18445 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18446 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18447 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18448 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18449 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18450 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18451 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18452 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18453 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18454 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18455 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18456 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18457 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18458 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18459 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18460 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18461 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18462 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18463 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18464 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18465 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       120
18466 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lts
18467 
18468 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lts
18469 
18470   /* The residual arity for this instruction does not depend on fast labels. */
18471   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
18472 
18473 
18474 #if defined (JITTER_PROFILE_SAMPLE)
18475   JITTER_PROFILE_SAMPLE_UPDATE
18476      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18477       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18478   /* Force the compiler not move sample-profiling instrumentation
18479      beyond this point; this way the actual user code is timed.
18480      This is still not perfect, as residuals are materialised before
18481      we arrive here, but should be adequate at least for slow VM
18482      instructions. */
18483   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18484 #endif
18485 #if defined (JITTER_PROFILE_COUNT)
18486   /* Notice that, differently from the code above, this
18487      instrumentation code *can* be reordered freely: as long as a
18488      VM instruction is counted, the count increment can be placed
18489      anyehere.  Let GCC move this code and possibly achieve better
18490      throughput by exploiting instruction-level parallelism and
18491      therefore approximate more closely a non-profiled build. */
18492   JITTER_PROFILE_COUNT_UPDATE
18493      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18494       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18495 #endif
18496 
18497 /* User-specified code, instruction-beginning-c part: beginning. */
18498 
18499 /* User-specified code, instruction-beginning-c part: end */
18500 
18501 
18502     /* User code for lts . */
18503 #line 3054 "../../libpoke/pvm.jitter"
18504 
18505     pvm_val res = PVM_MAKE_INT (strcmp (PVM_VAL_STR (JITTER_UNDER_TOP_STACK ()),
18506                                         PVM_VAL_STR (JITTER_TOP_STACK ())) < 0, 32);
18507     JITTER_PUSH_STACK (res);
18508 
18509     /* End of the user code for lts . */
18510 
18511 /* User-specified code, instruction-end-c part: beginning. */
18512 
18513 /* User-specified code, instruction-end-c part: end */
18514 
18515     /* Undefine the lts argument macros so they can't be used
18516        by mistake in the instruction body coming next. */
18517 
18518 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18519 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18520 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18521 
18522   }
18523  JITTER_INSTRUCTION_EPILOG_(lts, lts, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18524 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18525 
18526   JITTER_INSTRUCTION_PROLOG_(lutoi/nR, lutoi__nR, cold)
18527   {
18528     /* This specialized instruction is not a replacement. */
18529 #   undef JITTER_BRANCH_FAST
18530 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18531 #   undef JITTER_BRANCH_FAST_IF_ZERO
18532 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18533 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18534 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18535 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18536 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18537 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18538 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18539 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18540 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18541 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18542 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18543 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18544 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18545 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18546 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18547 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18548 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18549 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18550 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18551 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18552 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18553 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18554 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18555 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18556 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18557 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18558 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18559 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18560 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18561 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18562 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18563 #   undef JITTER_BRANCH_FAST_IF_AND
18564 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18565 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18566 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18567 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18568 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18569 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18570 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18571 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18572 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18573 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18574 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18575 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18576 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18577 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18578 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18579 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18580 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18581 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18582 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18583 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18584 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18585 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18586 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18587 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18588 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18589 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18590 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18591 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18592 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18593 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       121
18594 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lutoi/nR
18595 
18596 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lutoi__nR
18597 
18598   /* The residual arity for this instruction does not depend on fast labels. */
18599   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18600 
18601     /* The 0th argument is a residual literal. */
18602 #if defined(JITTER_DISPATCH_NO_THREADING)
18603 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18604     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18605 #elif defined (JITTER_REPLICATE)
18606 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18607 #else
18608 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18609 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18610 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18611 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18612 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18613 #   define JITTER_ARGF0 JITTER_ARGP0
18614 
18615 
18616 #if defined (JITTER_PROFILE_SAMPLE)
18617   JITTER_PROFILE_SAMPLE_UPDATE
18618      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18619       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18620   /* Force the compiler not move sample-profiling instrumentation
18621      beyond this point; this way the actual user code is timed.
18622      This is still not perfect, as residuals are materialised before
18623      we arrive here, but should be adequate at least for slow VM
18624      instructions. */
18625   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18626 #endif
18627 #if defined (JITTER_PROFILE_COUNT)
18628   /* Notice that, differently from the code above, this
18629      instrumentation code *can* be reordered freely: as long as a
18630      VM instruction is counted, the count increment can be placed
18631      anyehere.  Let GCC move this code and possibly achieve better
18632      throughput by exploiting instruction-level parallelism and
18633      therefore approximate more closely a non-profiled build. */
18634   JITTER_PROFILE_COUNT_UPDATE
18635      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18636       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18637 #endif
18638 
18639 /* User-specified code, instruction-beginning-c part: beginning. */
18640 
18641 /* User-specified code, instruction-beginning-c part: end */
18642 
18643 
18644     /* User code for lutoi/nR . */
18645 #line 3945 "../../libpoke/pvm.jitter"
18646 
18647     PVM_CONVOP (ULONG, uint64_t, int, int32_t);
18648 
18649     /* End of the user code for lutoi/nR . */
18650 
18651 /* User-specified code, instruction-end-c part: beginning. */
18652 
18653 /* User-specified code, instruction-end-c part: end */
18654 
18655     /* Undefine the lutoi/nR argument macros so they can't be used
18656        by mistake in the instruction body coming next. */
18657 #   undef JITTER_SLOW_REGISTER_OFFSET0
18658 #   undef JITTER_ARG0
18659 #   undef JITTER_ARGN0
18660 #   undef JITTER_ARGU0
18661 #   undef JITTER_ARGP0
18662 #   undef JITTER_ARGF0
18663 
18664 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18665 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18666 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18667 
18668   }
18669  JITTER_INSTRUCTION_EPILOG_(lutoi/nR, lutoi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18670 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18671 
18672   JITTER_INSTRUCTION_PROLOG_(lutoiu/nR, lutoiu__nR, cold)
18673   {
18674     /* This specialized instruction is not a replacement. */
18675 #   undef JITTER_BRANCH_FAST
18676 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18677 #   undef JITTER_BRANCH_FAST_IF_ZERO
18678 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18679 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18680 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18681 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18682 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18683 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18684 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18685 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18686 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18687 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18688 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18689 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18690 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18691 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18692 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18693 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18694 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18695 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18696 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18697 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18698 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18699 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18700 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18701 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18702 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18703 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18704 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18705 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18706 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18707 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18708 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18709 #   undef JITTER_BRANCH_FAST_IF_AND
18710 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18711 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18712 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18713 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18714 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18715 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18716 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18717 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18718 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18719 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18720 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18721 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18722 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18723 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18724 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18725 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18726 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18727 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18728 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18729 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18730 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18731 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18732 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18733 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18734 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18735 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18736 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18737 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18738 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18739 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       122
18740 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lutoiu/nR
18741 
18742 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lutoiu__nR
18743 
18744   /* The residual arity for this instruction does not depend on fast labels. */
18745   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18746 
18747     /* The 0th argument is a residual literal. */
18748 #if defined(JITTER_DISPATCH_NO_THREADING)
18749 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18750     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18751 #elif defined (JITTER_REPLICATE)
18752 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18753 #else
18754 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18755 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18756 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18757 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18758 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18759 #   define JITTER_ARGF0 JITTER_ARGP0
18760 
18761 
18762 #if defined (JITTER_PROFILE_SAMPLE)
18763   JITTER_PROFILE_SAMPLE_UPDATE
18764      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18765       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18766   /* Force the compiler not move sample-profiling instrumentation
18767      beyond this point; this way the actual user code is timed.
18768      This is still not perfect, as residuals are materialised before
18769      we arrive here, but should be adequate at least for slow VM
18770      instructions. */
18771   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18772 #endif
18773 #if defined (JITTER_PROFILE_COUNT)
18774   /* Notice that, differently from the code above, this
18775      instrumentation code *can* be reordered freely: as long as a
18776      VM instruction is counted, the count increment can be placed
18777      anyehere.  Let GCC move this code and possibly achieve better
18778      throughput by exploiting instruction-level parallelism and
18779      therefore approximate more closely a non-profiled build. */
18780   JITTER_PROFILE_COUNT_UPDATE
18781      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18782       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18783 #endif
18784 
18785 /* User-specified code, instruction-beginning-c part: beginning. */
18786 
18787 /* User-specified code, instruction-beginning-c part: end */
18788 
18789 
18790     /* User code for lutoiu/nR . */
18791 #line 3960 "../../libpoke/pvm.jitter"
18792 
18793     PVM_CONVOP (ULONG, uint64_t, uint, uint32_t);
18794 
18795     /* End of the user code for lutoiu/nR . */
18796 
18797 /* User-specified code, instruction-end-c part: beginning. */
18798 
18799 /* User-specified code, instruction-end-c part: end */
18800 
18801     /* Undefine the lutoiu/nR argument macros so they can't be used
18802        by mistake in the instruction body coming next. */
18803 #   undef JITTER_SLOW_REGISTER_OFFSET0
18804 #   undef JITTER_ARG0
18805 #   undef JITTER_ARGN0
18806 #   undef JITTER_ARGU0
18807 #   undef JITTER_ARGP0
18808 #   undef JITTER_ARGF0
18809 
18810 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18811 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18812 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18813 
18814   }
18815  JITTER_INSTRUCTION_EPILOG_(lutoiu/nR, lutoiu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18816 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18817 
18818   JITTER_INSTRUCTION_PROLOG_(lutol/nR, lutol__nR, cold)
18819   {
18820     /* This specialized instruction is not a replacement. */
18821 #   undef JITTER_BRANCH_FAST
18822 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18823 #   undef JITTER_BRANCH_FAST_IF_ZERO
18824 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18825 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18826 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18827 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18828 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18829 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18830 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18831 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18832 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18833 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18834 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18835 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18836 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18837 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18838 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18839 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18840 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18841 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18842 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18843 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18844 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18845 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18846 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18847 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18848 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18849 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18850 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18851 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18852 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18853 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18854 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18855 #   undef JITTER_BRANCH_FAST_IF_AND
18856 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18857 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18858 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18859 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18860 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18861 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18862 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18863 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18864 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18865 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18866 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18867 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18868 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18869 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18870 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18871 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18872 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18873 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18874 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18875 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18876 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18877 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18878 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18879 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18880 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18881 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18882 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18883 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18884 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18885 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       123
18886 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lutol/nR
18887 
18888 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lutol__nR
18889 
18890   /* The residual arity for this instruction does not depend on fast labels. */
18891   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18892 
18893     /* The 0th argument is a residual literal. */
18894 #if defined(JITTER_DISPATCH_NO_THREADING)
18895 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18896     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18897 #elif defined (JITTER_REPLICATE)
18898 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18899 #else
18900 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18901 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18902 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18903 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18904 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18905 #   define JITTER_ARGF0 JITTER_ARGP0
18906 
18907 
18908 #if defined (JITTER_PROFILE_SAMPLE)
18909   JITTER_PROFILE_SAMPLE_UPDATE
18910      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18911       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18912   /* Force the compiler not move sample-profiling instrumentation
18913      beyond this point; this way the actual user code is timed.
18914      This is still not perfect, as residuals are materialised before
18915      we arrive here, but should be adequate at least for slow VM
18916      instructions. */
18917   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18918 #endif
18919 #if defined (JITTER_PROFILE_COUNT)
18920   /* Notice that, differently from the code above, this
18921      instrumentation code *can* be reordered freely: as long as a
18922      VM instruction is counted, the count increment can be placed
18923      anyehere.  Let GCC move this code and possibly achieve better
18924      throughput by exploiting instruction-level parallelism and
18925      therefore approximate more closely a non-profiled build. */
18926   JITTER_PROFILE_COUNT_UPDATE
18927      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18928       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18929 #endif
18930 
18931 /* User-specified code, instruction-beginning-c part: beginning. */
18932 
18933 /* User-specified code, instruction-beginning-c part: end */
18934 
18935 
18936     /* User code for lutol/nR . */
18937 #line 3973 "../../libpoke/pvm.jitter"
18938 
18939     PVM_CONVOP (ULONG, uint64_t, long, int64_t);
18940 
18941     /* End of the user code for lutol/nR . */
18942 
18943 /* User-specified code, instruction-end-c part: beginning. */
18944 
18945 /* User-specified code, instruction-end-c part: end */
18946 
18947     /* Undefine the lutol/nR argument macros so they can't be used
18948        by mistake in the instruction body coming next. */
18949 #   undef JITTER_SLOW_REGISTER_OFFSET0
18950 #   undef JITTER_ARG0
18951 #   undef JITTER_ARGN0
18952 #   undef JITTER_ARGU0
18953 #   undef JITTER_ARGP0
18954 #   undef JITTER_ARGF0
18955 
18956 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18957 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18958 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18959 
18960   }
18961  JITTER_INSTRUCTION_EPILOG_(lutol/nR, lutol__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18962 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18963 
18964   JITTER_INSTRUCTION_PROLOG_(lutolu/nR, lutolu__nR, cold)
18965   {
18966     /* This specialized instruction is not a replacement. */
18967 #   undef JITTER_BRANCH_FAST
18968 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18969 #   undef JITTER_BRANCH_FAST_IF_ZERO
18970 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18971 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18972 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18973 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18974 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18975 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18976 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18977 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18978 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18979 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18980 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18981 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18982 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18983 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18984 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18985 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18986 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18987 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18988 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18989 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18990 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18991 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18992 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18993 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18994 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18995 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18996 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18997 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18998 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18999 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19000 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19001 #   undef JITTER_BRANCH_FAST_IF_AND
19002 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19003 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19004 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19005 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19006 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19007 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19008 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19009 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19010 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19011 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19012 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19013 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19014 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19015 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19016 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19017 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19018 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19019 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19020 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19021 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19022 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19023 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19024 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19025 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19026 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19027 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19028 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19029 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19030 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19031 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       124
19032 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         lutolu/nR
19033 
19034 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME lutolu__nR
19035 
19036   /* The residual arity for this instruction does not depend on fast labels. */
19037   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
19038 
19039     /* The 0th argument is a residual literal. */
19040 #if defined(JITTER_DISPATCH_NO_THREADING)
19041 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
19042     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
19043 #elif defined (JITTER_REPLICATE)
19044 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
19045 #else
19046 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
19047 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
19048 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19049 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19050 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19051 #   define JITTER_ARGF0 JITTER_ARGP0
19052 
19053 
19054 #if defined (JITTER_PROFILE_SAMPLE)
19055   JITTER_PROFILE_SAMPLE_UPDATE
19056      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19057       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19058   /* Force the compiler not move sample-profiling instrumentation
19059      beyond this point; this way the actual user code is timed.
19060      This is still not perfect, as residuals are materialised before
19061      we arrive here, but should be adequate at least for slow VM
19062      instructions. */
19063   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19064 #endif
19065 #if defined (JITTER_PROFILE_COUNT)
19066   /* Notice that, differently from the code above, this
19067      instrumentation code *can* be reordered freely: as long as a
19068      VM instruction is counted, the count increment can be placed
19069      anyehere.  Let GCC move this code and possibly achieve better
19070      throughput by exploiting instruction-level parallelism and
19071      therefore approximate more closely a non-profiled build. */
19072   JITTER_PROFILE_COUNT_UPDATE
19073      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19074       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19075 #endif
19076 
19077 /* User-specified code, instruction-beginning-c part: beginning. */
19078 
19079 /* User-specified code, instruction-beginning-c part: end */
19080 
19081 
19082     /* User code for lutolu/nR . */
19083 #line 3986 "../../libpoke/pvm.jitter"
19084 
19085     PVM_CONVOP (ULONG, uint64_t, ulong, uint64_t);
19086 
19087     /* End of the user code for lutolu/nR . */
19088 
19089 /* User-specified code, instruction-end-c part: beginning. */
19090 
19091 /* User-specified code, instruction-end-c part: end */
19092 
19093     /* Undefine the lutolu/nR argument macros so they can't be used
19094        by mistake in the instruction body coming next. */
19095 #   undef JITTER_SLOW_REGISTER_OFFSET0
19096 #   undef JITTER_ARG0
19097 #   undef JITTER_ARGN0
19098 #   undef JITTER_ARGU0
19099 #   undef JITTER_ARGP0
19100 #   undef JITTER_ARGF0
19101 
19102 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19103 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19104 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19105 
19106   }
19107  JITTER_INSTRUCTION_EPILOG_(lutolu/nR, lutolu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19108 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19109 
19110   JITTER_INSTRUCTION_PROLOG_(map, map, hot)
19111   {
19112     /* This specialized instruction is not a replacement. */
19113 #   undef JITTER_BRANCH_FAST
19114 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19115 #   undef JITTER_BRANCH_FAST_IF_ZERO
19116 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19117 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19118 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19119 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19120 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19121 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19122 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19123 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19124 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19125 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19126 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19127 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19128 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19129 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19130 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19131 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19132 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19133 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19134 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19135 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19136 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19137 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19138 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19139 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19140 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19141 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19142 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19143 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19144 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19145 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19146 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19147 #   undef JITTER_BRANCH_FAST_IF_AND
19148 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19149 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19150 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19151 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19152 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19153 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19154 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19155 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19156 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19157 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19158 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19159 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19160 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19161 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19162 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19163 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19164 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19165 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19166 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19167 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19168 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19169 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19170 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19171 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19172 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19173 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19174 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19175 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19176 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19177 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       125
19178 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         map
19179 
19180 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME map
19181 
19182   /* The residual arity for this instruction does not depend on fast labels. */
19183   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19184 
19185 
19186 #if defined (JITTER_PROFILE_SAMPLE)
19187   JITTER_PROFILE_SAMPLE_UPDATE
19188      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19189       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19190   /* Force the compiler not move sample-profiling instrumentation
19191      beyond this point; this way the actual user code is timed.
19192      This is still not perfect, as residuals are materialised before
19193      we arrive here, but should be adequate at least for slow VM
19194      instructions. */
19195   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19196 #endif
19197 #if defined (JITTER_PROFILE_COUNT)
19198   /* Notice that, differently from the code above, this
19199      instrumentation code *can* be reordered freely: as long as a
19200      VM instruction is counted, the count increment can be placed
19201      anyehere.  Let GCC move this code and possibly achieve better
19202      throughput by exploiting instruction-level parallelism and
19203      therefore approximate more closely a non-profiled build. */
19204   JITTER_PROFILE_COUNT_UPDATE
19205      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19206       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19207 #endif
19208 
19209 /* User-specified code, instruction-beginning-c part: beginning. */
19210 
19211 /* User-specified code, instruction-beginning-c part: end */
19212 
19213 
19214     /* User code for map . */
19215 #line 4681 "../../libpoke/pvm.jitter"
19216 
19217     pvm_val val = JITTER_TOP_STACK ();
19218 
19219     if (!(PVM_IS_ARR (val) || PVM_IS_SCT (val)))
19220       PVM_RAISE_DFL (PVM_E_INVAL);
19221 
19222     PVM_VAL_SET_MAPPED_P (JITTER_TOP_STACK (), 1);
19223 
19224     /* End of the user code for map . */
19225 
19226 /* User-specified code, instruction-end-c part: beginning. */
19227 
19228 /* User-specified code, instruction-end-c part: end */
19229 
19230     /* Undefine the map argument macros so they can't be used
19231        by mistake in the instruction body coming next. */
19232 
19233 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19234 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19235 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19236 
19237   }
19238  JITTER_INSTRUCTION_EPILOG_(map, map, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19239 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19240 
19241   JITTER_INSTRUCTION_PROLOG_(mgetios, mgetios, hot)
19242   {
19243     /* This specialized instruction is not a replacement. */
19244 #   undef JITTER_BRANCH_FAST
19245 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19246 #   undef JITTER_BRANCH_FAST_IF_ZERO
19247 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19248 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19249 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19250 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19251 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19252 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19253 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19254 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19255 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19256 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19257 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19258 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19259 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19260 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19261 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19262 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19263 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19264 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19265 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19266 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19267 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19268 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19269 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19270 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19271 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19272 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19273 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19274 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19275 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19276 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19277 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19278 #   undef JITTER_BRANCH_FAST_IF_AND
19279 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19280 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19281 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19282 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19283 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19284 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19285 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19286 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19287 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19288 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19289 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19290 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19291 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19292 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19293 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19294 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19295 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19296 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19297 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19298 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19299 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19300 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19301 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19302 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19303 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19304 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19305 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19306 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19307 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19308 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       126
19309 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mgetios
19310 
19311 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mgetios
19312 
19313   /* The residual arity for this instruction does not depend on fast labels. */
19314   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19315 
19316 
19317 #if defined (JITTER_PROFILE_SAMPLE)
19318   JITTER_PROFILE_SAMPLE_UPDATE
19319      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19320       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19321   /* Force the compiler not move sample-profiling instrumentation
19322      beyond this point; this way the actual user code is timed.
19323      This is still not perfect, as residuals are materialised before
19324      we arrive here, but should be adequate at least for slow VM
19325      instructions. */
19326   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19327 #endif
19328 #if defined (JITTER_PROFILE_COUNT)
19329   /* Notice that, differently from the code above, this
19330      instrumentation code *can* be reordered freely: as long as a
19331      VM instruction is counted, the count increment can be placed
19332      anyehere.  Let GCC move this code and possibly achieve better
19333      throughput by exploiting instruction-level parallelism and
19334      therefore approximate more closely a non-profiled build. */
19335   JITTER_PROFILE_COUNT_UPDATE
19336      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19337       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19338 #endif
19339 
19340 /* User-specified code, instruction-beginning-c part: beginning. */
19341 
19342 /* User-specified code, instruction-beginning-c part: end */
19343 
19344 
19345     /* User code for mgetios . */
19346 #line 4821 "../../libpoke/pvm.jitter"
19347 
19348     JITTER_PUSH_STACK (PVM_VAL_IOS (JITTER_TOP_STACK ()));
19349 
19350     /* End of the user code for mgetios . */
19351 
19352 /* User-specified code, instruction-end-c part: beginning. */
19353 
19354 /* User-specified code, instruction-end-c part: end */
19355 
19356     /* Undefine the mgetios argument macros so they can't be used
19357        by mistake in the instruction body coming next. */
19358 
19359 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19360 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19361 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19362 
19363   }
19364  JITTER_INSTRUCTION_EPILOG_(mgetios, mgetios, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19365 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19366 
19367   JITTER_INSTRUCTION_PROLOG_(mgetm, mgetm, hot)
19368   {
19369     /* This specialized instruction is not a replacement. */
19370 #   undef JITTER_BRANCH_FAST
19371 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19372 #   undef JITTER_BRANCH_FAST_IF_ZERO
19373 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19374 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19375 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19376 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19377 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19378 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19379 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19380 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19381 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19382 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19383 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19384 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19385 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19386 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19387 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19388 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19389 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19390 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19391 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19392 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19393 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19394 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19395 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19396 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19397 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19398 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19399 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19400 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19401 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19402 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19403 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19404 #   undef JITTER_BRANCH_FAST_IF_AND
19405 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19406 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19407 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19408 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19409 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19410 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19411 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19412 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19413 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19414 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19415 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19416 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19417 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19418 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19419 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19420 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19421 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19422 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19423 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19424 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19425 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19426 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19427 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19428 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19429 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19430 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19431 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19432 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19433 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19434 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       127
19435 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mgetm
19436 
19437 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mgetm
19438 
19439   /* The residual arity for this instruction does not depend on fast labels. */
19440   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19441 
19442 
19443 #if defined (JITTER_PROFILE_SAMPLE)
19444   JITTER_PROFILE_SAMPLE_UPDATE
19445      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19446       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19447   /* Force the compiler not move sample-profiling instrumentation
19448      beyond this point; this way the actual user code is timed.
19449      This is still not perfect, as residuals are materialised before
19450      we arrive here, but should be adequate at least for slow VM
19451      instructions. */
19452   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19453 #endif
19454 #if defined (JITTER_PROFILE_COUNT)
19455   /* Notice that, differently from the code above, this
19456      instrumentation code *can* be reordered freely: as long as a
19457      VM instruction is counted, the count increment can be placed
19458      anyehere.  Let GCC move this code and possibly achieve better
19459      throughput by exploiting instruction-level parallelism and
19460      therefore approximate more closely a non-profiled build. */
19461   JITTER_PROFILE_COUNT_UPDATE
19462      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19463       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19464 #endif
19465 
19466 /* User-specified code, instruction-beginning-c part: beginning. */
19467 
19468 /* User-specified code, instruction-beginning-c part: end */
19469 
19470 
19471     /* User code for mgetm . */
19472 #line 4851 "../../libpoke/pvm.jitter"
19473 
19474      JITTER_PUSH_STACK (PVM_VAL_MAPPER (JITTER_TOP_STACK ()));
19475 
19476     /* End of the user code for mgetm . */
19477 
19478 /* User-specified code, instruction-end-c part: beginning. */
19479 
19480 /* User-specified code, instruction-end-c part: end */
19481 
19482     /* Undefine the mgetm argument macros so they can't be used
19483        by mistake in the instruction body coming next. */
19484 
19485 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19486 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19487 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19488 
19489   }
19490  JITTER_INSTRUCTION_EPILOG_(mgetm, mgetm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19491 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19492 
19493   JITTER_INSTRUCTION_PROLOG_(mgeto, mgeto, hot)
19494   {
19495     /* This specialized instruction is not a replacement. */
19496 #   undef JITTER_BRANCH_FAST
19497 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19498 #   undef JITTER_BRANCH_FAST_IF_ZERO
19499 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19500 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19501 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19502 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19503 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19504 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19505 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19506 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19507 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19508 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19509 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19510 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19511 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19512 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19513 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19514 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19515 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19516 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19517 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19518 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19519 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19520 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19521 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19522 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19523 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19524 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19525 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19526 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19527 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19528 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19529 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19530 #   undef JITTER_BRANCH_FAST_IF_AND
19531 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19532 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19533 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19534 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19535 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19536 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19537 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19538 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19539 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19540 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19541 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19542 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19543 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19544 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19545 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19546 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19547 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19548 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19549 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19550 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19551 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19552 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19553 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19554 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19555 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19556 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19557 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19558 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19559 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19560 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       128
19561 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mgeto
19562 
19563 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mgeto
19564 
19565   /* The residual arity for this instruction does not depend on fast labels. */
19566   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19567 
19568 
19569 #if defined (JITTER_PROFILE_SAMPLE)
19570   JITTER_PROFILE_SAMPLE_UPDATE
19571      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19572       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19573   /* Force the compiler not move sample-profiling instrumentation
19574      beyond this point; this way the actual user code is timed.
19575      This is still not perfect, as residuals are materialised before
19576      we arrive here, but should be adequate at least for slow VM
19577      instructions. */
19578   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19579 #endif
19580 #if defined (JITTER_PROFILE_COUNT)
19581   /* Notice that, differently from the code above, this
19582      instrumentation code *can* be reordered freely: as long as a
19583      VM instruction is counted, the count increment can be placed
19584      anyehere.  Let GCC move this code and possibly achieve better
19585      throughput by exploiting instruction-level parallelism and
19586      therefore approximate more closely a non-profiled build. */
19587   JITTER_PROFILE_COUNT_UPDATE
19588      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19589       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19590 #endif
19591 
19592 /* User-specified code, instruction-beginning-c part: beginning. */
19593 
19594 /* User-specified code, instruction-beginning-c part: end */
19595 
19596 
19597     /* User code for mgeto . */
19598 #line 4793 "../../libpoke/pvm.jitter"
19599 
19600     JITTER_PUSH_STACK (PVM_VAL_OFFSET (JITTER_TOP_STACK ()));
19601 
19602     /* End of the user code for mgeto . */
19603 
19604 /* User-specified code, instruction-end-c part: beginning. */
19605 
19606 /* User-specified code, instruction-end-c part: end */
19607 
19608     /* Undefine the mgeto argument macros so they can't be used
19609        by mistake in the instruction body coming next. */
19610 
19611 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19612 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19613 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19614 
19615   }
19616  JITTER_INSTRUCTION_EPILOG_(mgeto, mgeto, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19617 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19618 
19619   JITTER_INSTRUCTION_PROLOG_(mgets, mgets, hot)
19620   {
19621     /* This specialized instruction is not a replacement. */
19622 #   undef JITTER_BRANCH_FAST
19623 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19624 #   undef JITTER_BRANCH_FAST_IF_ZERO
19625 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19626 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19627 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19628 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19629 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19630 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19631 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19632 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19633 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19634 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19635 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19636 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19637 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19638 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19639 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19640 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19641 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19642 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19643 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19644 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19645 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19646 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19647 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19648 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19649 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19650 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19651 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19652 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19653 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19654 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19655 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19656 #   undef JITTER_BRANCH_FAST_IF_AND
19657 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19658 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19659 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19660 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19661 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19662 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19663 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19664 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19665 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19666 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19667 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19668 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19669 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19670 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19671 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19672 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19673 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19674 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19675 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19676 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19677 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19678 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19679 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19680 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19681 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19682 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19683 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19684 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19685 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19686 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       129
19687 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mgets
19688 
19689 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mgets
19690 
19691   /* The residual arity for this instruction does not depend on fast labels. */
19692   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19693 
19694 
19695 #if defined (JITTER_PROFILE_SAMPLE)
19696   JITTER_PROFILE_SAMPLE_UPDATE
19697      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19698       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19699   /* Force the compiler not move sample-profiling instrumentation
19700      beyond this point; this way the actual user code is timed.
19701      This is still not perfect, as residuals are materialised before
19702      we arrive here, but should be adequate at least for slow VM
19703      instructions. */
19704   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19705 #endif
19706 #if defined (JITTER_PROFILE_COUNT)
19707   /* Notice that, differently from the code above, this
19708      instrumentation code *can* be reordered freely: as long as a
19709      VM instruction is counted, the count increment can be placed
19710      anyehere.  Let GCC move this code and possibly achieve better
19711      throughput by exploiting instruction-level parallelism and
19712      therefore approximate more closely a non-profiled build. */
19713   JITTER_PROFILE_COUNT_UPDATE
19714      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19715       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19716 #endif
19717 
19718 /* User-specified code, instruction-beginning-c part: beginning. */
19719 
19720 /* User-specified code, instruction-beginning-c part: end */
19721 
19722 
19723     /* User code for mgets . */
19724 #line 4761 "../../libpoke/pvm.jitter"
19725 
19726     int strict_p = PVM_VAL_STRICT_P (JITTER_TOP_STACK ());
19727     JITTER_PUSH_STACK (PVM_MAKE_INT (strict_p, 32));
19728 
19729     /* End of the user code for mgets . */
19730 
19731 /* User-specified code, instruction-end-c part: beginning. */
19732 
19733 /* User-specified code, instruction-end-c part: end */
19734 
19735     /* Undefine the mgets argument macros so they can't be used
19736        by mistake in the instruction body coming next. */
19737 
19738 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19739 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19740 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19741 
19742   }
19743  JITTER_INSTRUCTION_EPILOG_(mgets, mgets, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19744 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19745 
19746   JITTER_INSTRUCTION_PROLOG_(mgetsel, mgetsel, hot)
19747   {
19748     /* This specialized instruction is not a replacement. */
19749 #   undef JITTER_BRANCH_FAST
19750 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19751 #   undef JITTER_BRANCH_FAST_IF_ZERO
19752 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19753 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19754 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19755 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19756 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19757 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19758 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19759 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19760 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19761 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19762 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19763 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19764 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19765 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19766 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19767 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19768 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19769 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19770 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19771 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19772 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19773 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19774 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19775 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19776 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19777 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19778 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19779 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19780 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19781 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19782 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19783 #   undef JITTER_BRANCH_FAST_IF_AND
19784 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19785 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19786 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19787 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19788 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19789 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19790 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19791 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19792 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19793 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19794 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19795 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19796 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19797 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19798 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19799 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19800 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19801 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19802 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19803 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19804 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19805 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19806 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19807 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19808 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19809 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19810 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19811 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19812 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19813 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       130
19814 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mgetsel
19815 
19816 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mgetsel
19817 
19818   /* The residual arity for this instruction does not depend on fast labels. */
19819   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19820 
19821 
19822 #if defined (JITTER_PROFILE_SAMPLE)
19823   JITTER_PROFILE_SAMPLE_UPDATE
19824      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19825       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19826   /* Force the compiler not move sample-profiling instrumentation
19827      beyond this point; this way the actual user code is timed.
19828      This is still not perfect, as residuals are materialised before
19829      we arrive here, but should be adequate at least for slow VM
19830      instructions. */
19831   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19832 #endif
19833 #if defined (JITTER_PROFILE_COUNT)
19834   /* Notice that, differently from the code above, this
19835      instrumentation code *can* be reordered freely: as long as a
19836      VM instruction is counted, the count increment can be placed
19837      anyehere.  Let GCC move this code and possibly achieve better
19838      throughput by exploiting instruction-level parallelism and
19839      therefore approximate more closely a non-profiled build. */
19840   JITTER_PROFILE_COUNT_UPDATE
19841      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19842       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19843 #endif
19844 
19845 /* User-specified code, instruction-beginning-c part: beginning. */
19846 
19847 /* User-specified code, instruction-beginning-c part: end */
19848 
19849 
19850     /* User code for mgetsel . */
19851 #line 4909 "../../libpoke/pvm.jitter"
19852 
19853     JITTER_PUSH_STACK (PVM_VAL_ELEMS_BOUND (JITTER_TOP_STACK ()));
19854 
19855     /* End of the user code for mgetsel . */
19856 
19857 /* User-specified code, instruction-end-c part: beginning. */
19858 
19859 /* User-specified code, instruction-end-c part: end */
19860 
19861     /* Undefine the mgetsel argument macros so they can't be used
19862        by mistake in the instruction body coming next. */
19863 
19864 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19865 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19866 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19867 
19868   }
19869  JITTER_INSTRUCTION_EPILOG_(mgetsel, mgetsel, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19870 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19871 
19872   JITTER_INSTRUCTION_PROLOG_(mgetsiz, mgetsiz, hot)
19873   {
19874     /* This specialized instruction is not a replacement. */
19875 #   undef JITTER_BRANCH_FAST
19876 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19877 #   undef JITTER_BRANCH_FAST_IF_ZERO
19878 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19879 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19880 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19881 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19882 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19883 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19884 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19885 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19886 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19887 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19888 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19889 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19890 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19891 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19892 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19893 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19894 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19895 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19896 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19897 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19898 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19899 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19900 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19901 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19902 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19903 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19904 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19905 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19906 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19907 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19908 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19909 #   undef JITTER_BRANCH_FAST_IF_AND
19910 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19911 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19912 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19913 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19914 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19915 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19916 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19917 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19918 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19919 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19920 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19921 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19922 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19923 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19924 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19925 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19926 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19927 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19928 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19929 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19930 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19931 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19932 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19933 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19934 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19935 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19936 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19937 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19938 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19939 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       131
19940 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mgetsiz
19941 
19942 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mgetsiz
19943 
19944   /* The residual arity for this instruction does not depend on fast labels. */
19945   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19946 
19947 
19948 #if defined (JITTER_PROFILE_SAMPLE)
19949   JITTER_PROFILE_SAMPLE_UPDATE
19950      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19951       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19952   /* Force the compiler not move sample-profiling instrumentation
19953      beyond this point; this way the actual user code is timed.
19954      This is still not perfect, as residuals are materialised before
19955      we arrive here, but should be adequate at least for slow VM
19956      instructions. */
19957   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19958 #endif
19959 #if defined (JITTER_PROFILE_COUNT)
19960   /* Notice that, differently from the code above, this
19961      instrumentation code *can* be reordered freely: as long as a
19962      VM instruction is counted, the count increment can be placed
19963      anyehere.  Let GCC move this code and possibly achieve better
19964      throughput by exploiting instruction-level parallelism and
19965      therefore approximate more closely a non-profiled build. */
19966   JITTER_PROFILE_COUNT_UPDATE
19967      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19968       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19969 #endif
19970 
19971 /* User-specified code, instruction-beginning-c part: beginning. */
19972 
19973 /* User-specified code, instruction-beginning-c part: end */
19974 
19975 
19976     /* User code for mgetsiz . */
19977 #line 4943 "../../libpoke/pvm.jitter"
19978 
19979     JITTER_PUSH_STACK (PVM_VAL_SIZE_BOUND (JITTER_TOP_STACK ()));
19980 
19981     /* End of the user code for mgetsiz . */
19982 
19983 /* User-specified code, instruction-end-c part: beginning. */
19984 
19985 /* User-specified code, instruction-end-c part: end */
19986 
19987     /* Undefine the mgetsiz argument macros so they can't be used
19988        by mistake in the instruction body coming next. */
19989 
19990 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19991 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19992 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19993 
19994   }
19995  JITTER_INSTRUCTION_EPILOG_(mgetsiz, mgetsiz, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19996 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19997 
19998   JITTER_INSTRUCTION_PROLOG_(mgetw, mgetw, hot)
19999   {
20000     /* This specialized instruction is not a replacement. */
20001 #   undef JITTER_BRANCH_FAST
20002 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20003 #   undef JITTER_BRANCH_FAST_IF_ZERO
20004 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20005 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20006 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20007 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20008 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20009 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20010 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20011 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20012 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20013 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20014 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20015 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20016 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20017 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20018 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20019 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20020 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20021 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20022 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20023 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20024 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20025 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20026 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20027 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20028 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20029 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20030 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20031 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20032 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20033 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20034 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20035 #   undef JITTER_BRANCH_FAST_IF_AND
20036 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20037 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20038 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20039 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20040 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20041 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20042 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20043 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20044 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20045 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20046 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20047 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20048 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20049 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20050 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20051 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20052 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20053 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20054 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20055 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20056 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20057 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20058 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20059 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20060 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20061 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20062 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20063 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20064 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20065 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       132
20066 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mgetw
20067 
20068 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mgetw
20069 
20070   /* The residual arity for this instruction does not depend on fast labels. */
20071   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20072 
20073 
20074 #if defined (JITTER_PROFILE_SAMPLE)
20075   JITTER_PROFILE_SAMPLE_UPDATE
20076      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20077       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20078   /* Force the compiler not move sample-profiling instrumentation
20079      beyond this point; this way the actual user code is timed.
20080      This is still not perfect, as residuals are materialised before
20081      we arrive here, but should be adequate at least for slow VM
20082      instructions. */
20083   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20084 #endif
20085 #if defined (JITTER_PROFILE_COUNT)
20086   /* Notice that, differently from the code above, this
20087      instrumentation code *can* be reordered freely: as long as a
20088      VM instruction is counted, the count increment can be placed
20089      anyehere.  Let GCC move this code and possibly achieve better
20090      throughput by exploiting instruction-level parallelism and
20091      therefore approximate more closely a non-profiled build. */
20092   JITTER_PROFILE_COUNT_UPDATE
20093      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20094       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20095 #endif
20096 
20097 /* User-specified code, instruction-beginning-c part: beginning. */
20098 
20099 /* User-specified code, instruction-beginning-c part: end */
20100 
20101 
20102     /* User code for mgetw . */
20103 #line 4878 "../../libpoke/pvm.jitter"
20104 
20105      JITTER_PUSH_STACK (PVM_VAL_WRITER (JITTER_TOP_STACK ()));
20106 
20107     /* End of the user code for mgetw . */
20108 
20109 /* User-specified code, instruction-end-c part: beginning. */
20110 
20111 /* User-specified code, instruction-end-c part: end */
20112 
20113     /* Undefine the mgetw argument macros so they can't be used
20114        by mistake in the instruction body coming next. */
20115 
20116 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20117 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20118 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20119 
20120   }
20121  JITTER_INSTRUCTION_EPILOG_(mgetw, mgetw, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20122 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20123 
20124   JITTER_INSTRUCTION_PROLOG_(mka, mka, hot)
20125   {
20126     /* This specialized instruction is not a replacement. */
20127 #   undef JITTER_BRANCH_FAST
20128 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20129 #   undef JITTER_BRANCH_FAST_IF_ZERO
20130 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20131 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20132 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20133 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20134 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20135 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20136 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20137 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20138 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20139 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20140 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20141 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20142 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20143 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20144 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20145 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20146 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20147 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20148 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20149 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20150 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20151 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20152 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20153 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20154 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20155 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20156 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20157 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20158 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20159 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20160 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20161 #   undef JITTER_BRANCH_FAST_IF_AND
20162 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20163 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20164 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20165 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20166 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20167 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20168 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20169 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20170 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20171 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20172 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20173 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20174 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20175 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20176 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20177 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20178 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20179 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20180 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20181 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20182 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20183 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20184 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20185 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20186 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20187 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20188 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20189 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20190 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20191 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       133
20192 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mka
20193 
20194 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mka
20195 
20196   /* The residual arity for this instruction does not depend on fast labels. */
20197   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20198 
20199 
20200 #if defined (JITTER_PROFILE_SAMPLE)
20201   JITTER_PROFILE_SAMPLE_UPDATE
20202      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20203       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20204   /* Force the compiler not move sample-profiling instrumentation
20205      beyond this point; this way the actual user code is timed.
20206      This is still not perfect, as residuals are materialised before
20207      we arrive here, but should be adequate at least for slow VM
20208      instructions. */
20209   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20210 #endif
20211 #if defined (JITTER_PROFILE_COUNT)
20212   /* Notice that, differently from the code above, this
20213      instrumentation code *can* be reordered freely: as long as a
20214      VM instruction is counted, the count increment can be placed
20215      anyehere.  Let GCC move this code and possibly achieve better
20216      throughput by exploiting instruction-level parallelism and
20217      therefore approximate more closely a non-profiled build. */
20218   JITTER_PROFILE_COUNT_UPDATE
20219      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20220       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20221 #endif
20222 
20223 /* User-specified code, instruction-beginning-c part: beginning. */
20224 
20225 /* User-specified code, instruction-beginning-c part: end */
20226 
20227 
20228     /* User code for mka . */
20229 #line 4103 "../../libpoke/pvm.jitter"
20230 
20231     pvm_val arr = pvm_make_array (JITTER_TOP_STACK (),
20232                                   JITTER_UNDER_TOP_STACK ());
20233 
20234     PVM_VAL_ARR_OFFSET (arr) = PVM_MAKE_ULONG (0, 64);
20235     JITTER_DROP_STACK ();
20236     JITTER_DROP_STACK ();
20237     JITTER_PUSH_STACK (arr);
20238 
20239     /* End of the user code for mka . */
20240 
20241 /* User-specified code, instruction-end-c part: beginning. */
20242 
20243 /* User-specified code, instruction-end-c part: end */
20244 
20245     /* Undefine the mka argument macros so they can't be used
20246        by mistake in the instruction body coming next. */
20247 
20248 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20249 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20250 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20251 
20252   }
20253  JITTER_INSTRUCTION_EPILOG_(mka, mka, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20254 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20255 
20256   JITTER_INSTRUCTION_PROLOG_(mko, mko, hot)
20257   {
20258     /* This specialized instruction is not a replacement. */
20259 #   undef JITTER_BRANCH_FAST
20260 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20261 #   undef JITTER_BRANCH_FAST_IF_ZERO
20262 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20263 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20264 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20265 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20266 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20267 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20268 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20269 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20270 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20271 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20272 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20273 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20274 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20275 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20276 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20277 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20278 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20279 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20280 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20281 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20282 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20283 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20284 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20285 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20286 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20287 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20288 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20289 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20290 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20291 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20292 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20293 #   undef JITTER_BRANCH_FAST_IF_AND
20294 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20295 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20296 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20297 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20298 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20299 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20300 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20301 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20302 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20303 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20304 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20305 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20306 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20307 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20308 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20309 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20310 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20311 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20312 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20313 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20314 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20315 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20316 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20317 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20318 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20319 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20320 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20321 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20322 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20323 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       134
20324 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mko
20325 
20326 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mko
20327 
20328   /* The residual arity for this instruction does not depend on fast labels. */
20329   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20330 
20331 
20332 #if defined (JITTER_PROFILE_SAMPLE)
20333   JITTER_PROFILE_SAMPLE_UPDATE
20334      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20335       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20336   /* Force the compiler not move sample-profiling instrumentation
20337      beyond this point; this way the actual user code is timed.
20338      This is still not perfect, as residuals are materialised before
20339      we arrive here, but should be adequate at least for slow VM
20340      instructions. */
20341   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20342 #endif
20343 #if defined (JITTER_PROFILE_COUNT)
20344   /* Notice that, differently from the code above, this
20345      instrumentation code *can* be reordered freely: as long as a
20346      VM instruction is counted, the count increment can be placed
20347      anyehere.  Let GCC move this code and possibly achieve better
20348      throughput by exploiting instruction-level parallelism and
20349      therefore approximate more closely a non-profiled build. */
20350   JITTER_PROFILE_COUNT_UPDATE
20351      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20352       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20353 #endif
20354 
20355 /* User-specified code, instruction-beginning-c part: beginning. */
20356 
20357 /* User-specified code, instruction-beginning-c part: end */
20358 
20359 
20360     /* User code for mko . */
20361 #line 4595 "../../libpoke/pvm.jitter"
20362 
20363    pvm_val res = pvm_make_offset (JITTER_UNDER_TOP_STACK (),
20364                                   JITTER_TOP_STACK ());
20365    JITTER_DROP_STACK ();
20366    JITTER_TOP_STACK () = res;
20367 
20368     /* End of the user code for mko . */
20369 
20370 /* User-specified code, instruction-end-c part: beginning. */
20371 
20372 /* User-specified code, instruction-end-c part: end */
20373 
20374     /* Undefine the mko argument macros so they can't be used
20375        by mistake in the instruction body coming next. */
20376 
20377 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20378 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20379 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20380 
20381   }
20382  JITTER_INSTRUCTION_EPILOG_(mko, mko, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20383 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20384 
20385   JITTER_INSTRUCTION_PROLOG_(mksct, mksct, hot)
20386   {
20387     /* This specialized instruction is not a replacement. */
20388 #   undef JITTER_BRANCH_FAST
20389 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20390 #   undef JITTER_BRANCH_FAST_IF_ZERO
20391 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20392 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20393 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20394 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20395 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20396 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20397 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20398 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20399 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20400 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20401 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20402 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20403 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20404 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20405 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20406 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20407 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20408 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20409 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20410 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20411 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20412 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20413 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20414 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20415 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20416 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20417 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20418 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20419 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20420 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20421 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20422 #   undef JITTER_BRANCH_FAST_IF_AND
20423 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20424 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20425 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20426 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20427 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20428 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20429 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20430 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20431 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20432 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20433 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20434 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20435 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20436 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20437 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20438 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20439 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20440 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20441 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20442 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20443 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20444 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20445 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20446 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20447 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20448 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20449 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20450 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20451 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20452 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       135
20453 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mksct
20454 
20455 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mksct
20456 
20457   /* The residual arity for this instruction does not depend on fast labels. */
20458   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20459 
20460 
20461 #if defined (JITTER_PROFILE_SAMPLE)
20462   JITTER_PROFILE_SAMPLE_UPDATE
20463      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20464       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20465   /* Force the compiler not move sample-profiling instrumentation
20466      beyond this point; this way the actual user code is timed.
20467      This is still not perfect, as residuals are materialised before
20468      we arrive here, but should be adequate at least for slow VM
20469      instructions. */
20470   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20471 #endif
20472 #if defined (JITTER_PROFILE_COUNT)
20473   /* Notice that, differently from the code above, this
20474      instrumentation code *can* be reordered freely: as long as a
20475      VM instruction is counted, the count increment can be placed
20476      anyehere.  Let GCC move this code and possibly achieve better
20477      throughput by exploiting instruction-level parallelism and
20478      therefore approximate more closely a non-profiled build. */
20479   JITTER_PROFILE_COUNT_UPDATE
20480      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20481       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20482 #endif
20483 
20484 /* User-specified code, instruction-beginning-c part: beginning. */
20485 
20486 /* User-specified code, instruction-beginning-c part: end */
20487 
20488 
20489     /* User code for mksct . */
20490 #line 4335 "../../libpoke/pvm.jitter"
20491 
20492     size_t e;
20493     pvm_val nfields, nmethods, sct, type;
20494 
20495     type = JITTER_TOP_STACK ();
20496     JITTER_DROP_STACK ();
20497 
20498     nfields = JITTER_TOP_STACK ();
20499     JITTER_DROP_STACK ();
20500 
20501     nmethods = JITTER_TOP_STACK ();
20502     JITTER_DROP_STACK ();
20503 
20504     sct = pvm_make_struct (nfields, nmethods, type);
20505 
20506     for (e = 0; e < PVM_VAL_ULONG (nmethods); ++e)
20507     {
20508       PVM_VAL_SCT_METHOD_VALUE (sct, PVM_VAL_ULONG (nmethods) - e - 1)
20509          = JITTER_TOP_STACK ();
20510       PVM_VAL_SCT_METHOD_NAME (sct, PVM_VAL_ULONG (nmethods) - e - 1)
20511          = JITTER_UNDER_TOP_STACK ();
20512 
20513       JITTER_DROP_STACK ();
20514       JITTER_DROP_STACK ();
20515     }
20516 
20517     for (e = 0; e < PVM_VAL_ULONG (nfields); ++e)
20518     {
20519       PVM_VAL_SCT_FIELD_VALUE (sct, PVM_VAL_ULONG (nfields) - e - 1)
20520           = JITTER_TOP_STACK ();
20521       PVM_VAL_SCT_FIELD_NAME (sct, PVM_VAL_ULONG (nfields) - e - 1)
20522           = JITTER_UNDER_TOP_STACK ();
20523 
20524       JITTER_DROP_STACK ();
20525       JITTER_DROP_STACK ();
20526 
20527       PVM_VAL_SCT_FIELD_OFFSET (sct, PVM_VAL_ULONG (nfields) - e -1)
20528           = JITTER_TOP_STACK ();
20529       JITTER_DROP_STACK ();
20530     }
20531 
20532     PVM_VAL_SCT_OFFSET (sct) = JITTER_TOP_STACK();
20533     JITTER_DROP_STACK ();
20534 
20535     JITTER_PUSH_STACK (sct);
20536 
20537     /* End of the user code for mksct . */
20538 
20539 /* User-specified code, instruction-end-c part: beginning. */
20540 
20541 /* User-specified code, instruction-end-c part: end */
20542 
20543     /* Undefine the mksct argument macros so they can't be used
20544        by mistake in the instruction body coming next. */
20545 
20546 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20547 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20548 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20549 
20550   }
20551  JITTER_INSTRUCTION_EPILOG_(mksct, mksct, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20552 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20553 
20554   JITTER_INSTRUCTION_PROLOG_(mktya, mktya, hot)
20555   {
20556     /* This specialized instruction is not a replacement. */
20557 #   undef JITTER_BRANCH_FAST
20558 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20559 #   undef JITTER_BRANCH_FAST_IF_ZERO
20560 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20561 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20562 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20563 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20564 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20565 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20566 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20567 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20568 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20569 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20570 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20571 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20572 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20573 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20574 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20575 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20576 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20577 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20578 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20579 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20580 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20581 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20582 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20583 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20584 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20585 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20586 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20587 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20588 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20589 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20590 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20591 #   undef JITTER_BRANCH_FAST_IF_AND
20592 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20593 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20594 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20595 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20596 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20597 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20598 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20599 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20600 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20601 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20602 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20603 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20604 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20605 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20606 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20607 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20608 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20609 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20610 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20611 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20612 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20613 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20614 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20615 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20616 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20617 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20618 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20619 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20620 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20621 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       136
20622 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktya
20623 
20624 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktya
20625 
20626   /* The residual arity for this instruction does not depend on fast labels. */
20627   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20628 
20629 
20630 #if defined (JITTER_PROFILE_SAMPLE)
20631   JITTER_PROFILE_SAMPLE_UPDATE
20632      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20633       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20634   /* Force the compiler not move sample-profiling instrumentation
20635      beyond this point; this way the actual user code is timed.
20636      This is still not perfect, as residuals are materialised before
20637      we arrive here, but should be adequate at least for slow VM
20638      instructions. */
20639   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20640 #endif
20641 #if defined (JITTER_PROFILE_COUNT)
20642   /* Notice that, differently from the code above, this
20643      instrumentation code *can* be reordered freely: as long as a
20644      VM instruction is counted, the count increment can be placed
20645      anyehere.  Let GCC move this code and possibly achieve better
20646      throughput by exploiting instruction-level parallelism and
20647      therefore approximate more closely a non-profiled build. */
20648   JITTER_PROFILE_COUNT_UPDATE
20649      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20650       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20651 #endif
20652 
20653 /* User-specified code, instruction-beginning-c part: beginning. */
20654 
20655 /* User-specified code, instruction-beginning-c part: end */
20656 
20657 
20658     /* User code for mktya . */
20659 #line 5104 "../../libpoke/pvm.jitter"
20660 
20661      pvm_val bound = JITTER_TOP_STACK ();
20662      pvm_val etype = JITTER_UNDER_TOP_STACK ();
20663 
20664      JITTER_DROP_STACK ();
20665      JITTER_TOP_STACK () = pvm_make_array_type (etype, bound);
20666 
20667     /* End of the user code for mktya . */
20668 
20669 /* User-specified code, instruction-end-c part: beginning. */
20670 
20671 /* User-specified code, instruction-end-c part: end */
20672 
20673     /* Undefine the mktya argument macros so they can't be used
20674        by mistake in the instruction body coming next. */
20675 
20676 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20677 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20678 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20679 
20680   }
20681  JITTER_INSTRUCTION_EPILOG_(mktya, mktya, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20682 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20683 
20684   JITTER_INSTRUCTION_PROLOG_(mktyany, mktyany, hot)
20685   {
20686     /* This specialized instruction is not a replacement. */
20687 #   undef JITTER_BRANCH_FAST
20688 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20689 #   undef JITTER_BRANCH_FAST_IF_ZERO
20690 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20691 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20692 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20693 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20694 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20695 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20696 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20697 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20698 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20699 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20700 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20701 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20702 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20703 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20704 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20705 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20706 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20707 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20708 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20709 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20710 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20711 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20712 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20713 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20714 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20715 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20716 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20717 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20718 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20719 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20720 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20721 #   undef JITTER_BRANCH_FAST_IF_AND
20722 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20723 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20724 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20725 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20726 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20727 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20728 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20729 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20730 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20731 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20732 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20733 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20734 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20735 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20736 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20737 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20738 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20739 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20740 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20741 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20742 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20743 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20744 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20745 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20746 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20747 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20748 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20749 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20750 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20751 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       137
20752 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktyany
20753 
20754 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktyany
20755 
20756   /* The residual arity for this instruction does not depend on fast labels. */
20757   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20758 
20759 
20760 #if defined (JITTER_PROFILE_SAMPLE)
20761   JITTER_PROFILE_SAMPLE_UPDATE
20762      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20763       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20764   /* Force the compiler not move sample-profiling instrumentation
20765      beyond this point; this way the actual user code is timed.
20766      This is still not perfect, as residuals are materialised before
20767      we arrive here, but should be adequate at least for slow VM
20768      instructions. */
20769   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20770 #endif
20771 #if defined (JITTER_PROFILE_COUNT)
20772   /* Notice that, differently from the code above, this
20773      instrumentation code *can* be reordered freely: as long as a
20774      VM instruction is counted, the count increment can be placed
20775      anyehere.  Let GCC move this code and possibly achieve better
20776      throughput by exploiting instruction-level parallelism and
20777      therefore approximate more closely a non-profiled build. */
20778   JITTER_PROFILE_COUNT_UPDATE
20779      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20780       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20781 #endif
20782 
20783 /* User-specified code, instruction-beginning-c part: beginning. */
20784 
20785 /* User-specified code, instruction-beginning-c part: end */
20786 
20787 
20788     /* User code for mktyany . */
20789 #line 5043 "../../libpoke/pvm.jitter"
20790 
20791     JITTER_PUSH_STACK (pvm_make_any_type ());
20792 
20793     /* End of the user code for mktyany . */
20794 
20795 /* User-specified code, instruction-end-c part: beginning. */
20796 
20797 /* User-specified code, instruction-end-c part: end */
20798 
20799     /* Undefine the mktyany argument macros so they can't be used
20800        by mistake in the instruction body coming next. */
20801 
20802 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20803 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20804 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20805 
20806   }
20807  JITTER_INSTRUCTION_EPILOG_(mktyany, mktyany, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20808 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20809 
20810   JITTER_INSTRUCTION_PROLOG_(mktyc, mktyc, hot)
20811   {
20812     /* This specialized instruction is not a replacement. */
20813 #   undef JITTER_BRANCH_FAST
20814 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20815 #   undef JITTER_BRANCH_FAST_IF_ZERO
20816 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20817 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20818 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20819 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20820 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20821 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20822 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20823 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20824 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20825 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20826 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20827 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20828 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20829 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20830 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20831 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20832 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20833 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20834 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20835 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20836 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20837 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20838 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20839 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20840 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20841 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20842 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20843 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20844 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20845 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20846 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20847 #   undef JITTER_BRANCH_FAST_IF_AND
20848 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20849 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20850 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20851 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20852 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20853 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20854 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20855 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20856 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20857 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20858 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20859 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20860 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20861 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20862 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20863 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20864 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20865 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20866 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20867 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20868 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20869 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20870 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20871 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20872 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20873 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20874 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20875 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20876 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20877 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       138
20878 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktyc
20879 
20880 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktyc
20881 
20882   /* The residual arity for this instruction does not depend on fast labels. */
20883   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20884 
20885 
20886 #if defined (JITTER_PROFILE_SAMPLE)
20887   JITTER_PROFILE_SAMPLE_UPDATE
20888      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20889       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20890   /* Force the compiler not move sample-profiling instrumentation
20891      beyond this point; this way the actual user code is timed.
20892      This is still not perfect, as residuals are materialised before
20893      we arrive here, but should be adequate at least for slow VM
20894      instructions. */
20895   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20896 #endif
20897 #if defined (JITTER_PROFILE_COUNT)
20898   /* Notice that, differently from the code above, this
20899      instrumentation code *can* be reordered freely: as long as a
20900      VM instruction is counted, the count increment can be placed
20901      anyehere.  Let GCC move this code and possibly achieve better
20902      throughput by exploiting instruction-level parallelism and
20903      therefore approximate more closely a non-profiled build. */
20904   JITTER_PROFILE_COUNT_UPDATE
20905      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20906       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20907 #endif
20908 
20909 /* User-specified code, instruction-beginning-c part: beginning. */
20910 
20911 /* User-specified code, instruction-beginning-c part: end */
20912 
20913 
20914     /* User code for mktyc . */
20915 #line 5145 "../../libpoke/pvm.jitter"
20916 
20917     size_t i;
20918     pvm_val nargs, rtype, *atypes;
20919 
20920     nargs = JITTER_TOP_STACK ();
20921     JITTER_DROP_STACK ();
20922 
20923     rtype = JITTER_TOP_STACK ();
20924     JITTER_DROP_STACK ();
20925 
20926     pvm_allocate_closure_attrs (nargs, &atypes);
20927 
20928     for (i = 0; i < PVM_VAL_ULONG (nargs); ++i)
20929     {
20930       atypes[i] = JITTER_TOP_STACK ();
20931       JITTER_DROP_STACK ();
20932     }
20933 
20934     JITTER_PUSH_STACK (pvm_make_closure_type (rtype,
20935                                               nargs, atypes));
20936 
20937     /* End of the user code for mktyc . */
20938 
20939 /* User-specified code, instruction-end-c part: beginning. */
20940 
20941 /* User-specified code, instruction-end-c part: end */
20942 
20943     /* Undefine the mktyc argument macros so they can't be used
20944        by mistake in the instruction body coming next. */
20945 
20946 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20947 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20948 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20949 
20950   }
20951  JITTER_INSTRUCTION_EPILOG_(mktyc, mktyc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20952 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20953 
20954   JITTER_INSTRUCTION_PROLOG_(mktyi, mktyi, hot)
20955   {
20956     /* This specialized instruction is not a replacement. */
20957 #   undef JITTER_BRANCH_FAST
20958 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20959 #   undef JITTER_BRANCH_FAST_IF_ZERO
20960 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20961 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20962 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20963 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20964 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20965 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20966 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20967 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20968 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20969 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20970 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20971 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20972 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20973 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20974 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20975 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20976 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20977 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20978 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20979 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20980 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20981 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20982 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20983 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20984 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20985 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20986 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20987 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20988 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20989 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20990 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20991 #   undef JITTER_BRANCH_FAST_IF_AND
20992 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20993 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20994 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20995 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20996 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20997 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20998 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20999 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21000 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21001 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21002 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21003 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21004 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21005 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21006 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21007 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21008 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21009 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21010 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21011 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21012 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21013 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21014 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21015 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21016 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21017 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21018 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21019 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21020 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21021 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       139
21022 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktyi
21023 
21024 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktyi
21025 
21026   /* The residual arity for this instruction does not depend on fast labels. */
21027   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21028 
21029 
21030 #if defined (JITTER_PROFILE_SAMPLE)
21031   JITTER_PROFILE_SAMPLE_UPDATE
21032      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21033       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21034   /* Force the compiler not move sample-profiling instrumentation
21035      beyond this point; this way the actual user code is timed.
21036      This is still not perfect, as residuals are materialised before
21037      we arrive here, but should be adequate at least for slow VM
21038      instructions. */
21039   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21040 #endif
21041 #if defined (JITTER_PROFILE_COUNT)
21042   /* Notice that, differently from the code above, this
21043      instrumentation code *can* be reordered freely: as long as a
21044      VM instruction is counted, the count increment can be placed
21045      anyehere.  Let GCC move this code and possibly achieve better
21046      throughput by exploiting instruction-level parallelism and
21047      therefore approximate more closely a non-profiled build. */
21048   JITTER_PROFILE_COUNT_UPDATE
21049      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21050       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21051 #endif
21052 
21053 /* User-specified code, instruction-beginning-c part: beginning. */
21054 
21055 /* User-specified code, instruction-beginning-c part: end */
21056 
21057 
21058     /* User code for mktyi . */
21059 #line 5057 "../../libpoke/pvm.jitter"
21060 
21061     pvm_val size = JITTER_UNDER_TOP_STACK ();
21062     pvm_val signed_p = JITTER_TOP_STACK ();
21063     JITTER_DROP_STACK ();
21064 
21065     JITTER_TOP_STACK () = pvm_make_integral_type (size, signed_p);
21066 
21067     /* End of the user code for mktyi . */
21068 
21069 /* User-specified code, instruction-end-c part: beginning. */
21070 
21071 /* User-specified code, instruction-end-c part: end */
21072 
21073     /* Undefine the mktyi argument macros so they can't be used
21074        by mistake in the instruction body coming next. */
21075 
21076 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21077 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21078 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21079 
21080   }
21081  JITTER_INSTRUCTION_EPILOG_(mktyi, mktyi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21082 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21083 
21084   JITTER_INSTRUCTION_PROLOG_(mktyo, mktyo, hot)
21085   {
21086     /* This specialized instruction is not a replacement. */
21087 #   undef JITTER_BRANCH_FAST
21088 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21089 #   undef JITTER_BRANCH_FAST_IF_ZERO
21090 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21091 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21092 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21093 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21094 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21095 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21096 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21097 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21098 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21099 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21100 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21101 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21102 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21103 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21104 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21105 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21106 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21107 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21108 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21109 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21110 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21111 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21112 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21113 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21114 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21115 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21116 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21117 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21118 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21119 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21120 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21121 #   undef JITTER_BRANCH_FAST_IF_AND
21122 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21123 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21124 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21125 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21126 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21127 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21128 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21129 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21130 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21131 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21132 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21133 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21134 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21135 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21136 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21137 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21138 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21139 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21140 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21141 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21142 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21143 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21144 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21145 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21146 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21147 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21148 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21149 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21150 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21151 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       140
21152 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktyo
21153 
21154 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktyo
21155 
21156   /* The residual arity for this instruction does not depend on fast labels. */
21157   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21158 
21159 
21160 #if defined (JITTER_PROFILE_SAMPLE)
21161   JITTER_PROFILE_SAMPLE_UPDATE
21162      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21163       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21164   /* Force the compiler not move sample-profiling instrumentation
21165      beyond this point; this way the actual user code is timed.
21166      This is still not perfect, as residuals are materialised before
21167      we arrive here, but should be adequate at least for slow VM
21168      instructions. */
21169   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21170 #endif
21171 #if defined (JITTER_PROFILE_COUNT)
21172   /* Notice that, differently from the code above, this
21173      instrumentation code *can* be reordered freely: as long as a
21174      VM instruction is counted, the count increment can be placed
21175      anyehere.  Let GCC move this code and possibly achieve better
21176      throughput by exploiting instruction-level parallelism and
21177      therefore approximate more closely a non-profiled build. */
21178   JITTER_PROFILE_COUNT_UPDATE
21179      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21180       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21181 #endif
21182 
21183 /* User-specified code, instruction-beginning-c part: beginning. */
21184 
21185 /* User-specified code, instruction-beginning-c part: end */
21186 
21187 
21188     /* User code for mktyo . */
21189 #line 5087 "../../libpoke/pvm.jitter"
21190 
21191 #define F(res, a, b) \
21192   { res = pvm_make_offset_type (a, b); }
21193     JITTER_BINARY_STACK(F);
21194 #undef F
21195 
21196     /* End of the user code for mktyo . */
21197 
21198 /* User-specified code, instruction-end-c part: beginning. */
21199 
21200 /* User-specified code, instruction-end-c part: end */
21201 
21202     /* Undefine the mktyo argument macros so they can't be used
21203        by mistake in the instruction body coming next. */
21204 
21205 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21206 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21207 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21208 
21209   }
21210  JITTER_INSTRUCTION_EPILOG_(mktyo, mktyo, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21211 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21212 
21213   JITTER_INSTRUCTION_PROLOG_(mktys, mktys, hot)
21214   {
21215     /* This specialized instruction is not a replacement. */
21216 #   undef JITTER_BRANCH_FAST
21217 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21218 #   undef JITTER_BRANCH_FAST_IF_ZERO
21219 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21220 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21221 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21222 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21223 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21224 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21225 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21226 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21227 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21228 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21229 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21230 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21231 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21232 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21233 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21234 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21235 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21236 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21237 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21238 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21239 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21240 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21241 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21242 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21243 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21244 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21245 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21246 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21247 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21248 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21249 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21250 #   undef JITTER_BRANCH_FAST_IF_AND
21251 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21252 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21253 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21254 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21255 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21256 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21257 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21258 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21259 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21260 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21261 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21262 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21263 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21264 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21265 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21266 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21267 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21268 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21269 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21270 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21271 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21272 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21273 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21274 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21275 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21276 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21277 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21278 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21279 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21280 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       141
21281 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktys
21282 
21283 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktys
21284 
21285   /* The residual arity for this instruction does not depend on fast labels. */
21286   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21287 
21288 
21289 #if defined (JITTER_PROFILE_SAMPLE)
21290   JITTER_PROFILE_SAMPLE_UPDATE
21291      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21292       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21293   /* Force the compiler not move sample-profiling instrumentation
21294      beyond this point; this way the actual user code is timed.
21295      This is still not perfect, as residuals are materialised before
21296      we arrive here, but should be adequate at least for slow VM
21297      instructions. */
21298   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21299 #endif
21300 #if defined (JITTER_PROFILE_COUNT)
21301   /* Notice that, differently from the code above, this
21302      instrumentation code *can* be reordered freely: as long as a
21303      VM instruction is counted, the count increment can be placed
21304      anyehere.  Let GCC move this code and possibly achieve better
21305      throughput by exploiting instruction-level parallelism and
21306      therefore approximate more closely a non-profiled build. */
21307   JITTER_PROFILE_COUNT_UPDATE
21308      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21309       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21310 #endif
21311 
21312 /* User-specified code, instruction-beginning-c part: beginning. */
21313 
21314 /* User-specified code, instruction-beginning-c part: end */
21315 
21316 
21317     /* User code for mktys . */
21318 #line 5073 "../../libpoke/pvm.jitter"
21319 
21320     JITTER_PUSH_STACK (pvm_make_string_type ());
21321 
21322     /* End of the user code for mktys . */
21323 
21324 /* User-specified code, instruction-end-c part: beginning. */
21325 
21326 /* User-specified code, instruction-end-c part: end */
21327 
21328     /* Undefine the mktys argument macros so they can't be used
21329        by mistake in the instruction body coming next. */
21330 
21331 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21332 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21333 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21334 
21335   }
21336  JITTER_INSTRUCTION_EPILOG_(mktys, mktys, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21337 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21338 
21339   JITTER_INSTRUCTION_PROLOG_(mktysct, mktysct, hot)
21340   {
21341     /* This specialized instruction is not a replacement. */
21342 #   undef JITTER_BRANCH_FAST
21343 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21344 #   undef JITTER_BRANCH_FAST_IF_ZERO
21345 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21346 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21347 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21348 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21349 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21350 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21351 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21352 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21353 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21354 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21355 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21356 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21357 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21358 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21359 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21360 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21361 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21362 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21363 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21364 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21365 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21366 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21367 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21368 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21369 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21370 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21371 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21372 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21373 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21374 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21375 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21376 #   undef JITTER_BRANCH_FAST_IF_AND
21377 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21378 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21379 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21380 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21381 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21382 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21383 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21384 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21385 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21386 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21387 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21388 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21389 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21390 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21391 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21392 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21393 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21394 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21395 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21396 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21397 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21398 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21399 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21400 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21401 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21402 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21403 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21404 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21405 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21406 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       142
21407 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktysct
21408 
21409 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktysct
21410 
21411   /* The residual arity for this instruction does not depend on fast labels. */
21412   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21413 
21414 
21415 #if defined (JITTER_PROFILE_SAMPLE)
21416   JITTER_PROFILE_SAMPLE_UPDATE
21417      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21418       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21419   /* Force the compiler not move sample-profiling instrumentation
21420      beyond this point; this way the actual user code is timed.
21421      This is still not perfect, as residuals are materialised before
21422      we arrive here, but should be adequate at least for slow VM
21423      instructions. */
21424   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21425 #endif
21426 #if defined (JITTER_PROFILE_COUNT)
21427   /* Notice that, differently from the code above, this
21428      instrumentation code *can* be reordered freely: as long as a
21429      VM instruction is counted, the count increment can be placed
21430      anyehere.  Let GCC move this code and possibly achieve better
21431      throughput by exploiting instruction-level parallelism and
21432      therefore approximate more closely a non-profiled build. */
21433   JITTER_PROFILE_COUNT_UPDATE
21434      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21435       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21436 #endif
21437 
21438 /* User-specified code, instruction-beginning-c part: beginning. */
21439 
21440 /* User-specified code, instruction-beginning-c part: end */
21441 
21442 
21443     /* User code for mktysct . */
21444 #line 5179 "../../libpoke/pvm.jitter"
21445 
21446     size_t i;
21447     pvm_val nelem, name, *etypes, *enames;
21448 
21449     name = JITTER_TOP_STACK ();
21450     JITTER_DROP_STACK ();
21451 
21452     nelem = JITTER_TOP_STACK ();
21453     JITTER_DROP_STACK ();
21454 
21455     pvm_allocate_struct_attrs (nelem, &etypes, &enames);
21456 
21457     for (i = 0; i < PVM_VAL_ULONG (nelem); ++i)
21458     {
21459       enames[PVM_VAL_ULONG (nelem) - i - 1] = JITTER_UNDER_TOP_STACK ();
21460       etypes[PVM_VAL_ULONG (nelem) - i - 1] = JITTER_TOP_STACK ();
21461 
21462       JITTER_DROP_STACK ();
21463       JITTER_DROP_STACK ();
21464     }
21465 
21466     JITTER_PUSH_STACK (pvm_make_struct_type (nelem, name,
21467                                              enames, etypes));
21468 
21469     /* End of the user code for mktysct . */
21470 
21471 /* User-specified code, instruction-end-c part: beginning. */
21472 
21473 /* User-specified code, instruction-end-c part: end */
21474 
21475     /* Undefine the mktysct argument macros so they can't be used
21476        by mistake in the instruction body coming next. */
21477 
21478 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21479 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21480 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21481 
21482   }
21483  JITTER_INSTRUCTION_EPILOG_(mktysct, mktysct, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21484 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21485 
21486   JITTER_INSTRUCTION_PROLOG_(mktyv, mktyv, hot)
21487   {
21488     /* This specialized instruction is not a replacement. */
21489 #   undef JITTER_BRANCH_FAST
21490 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21491 #   undef JITTER_BRANCH_FAST_IF_ZERO
21492 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21493 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21494 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21495 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21496 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21497 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21498 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21499 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21500 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21501 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21502 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21503 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21504 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21505 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21506 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21507 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21508 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21509 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21510 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21511 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21512 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21513 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21514 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21515 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21516 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21517 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21518 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21519 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21520 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21521 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21522 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21523 #   undef JITTER_BRANCH_FAST_IF_AND
21524 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21525 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21526 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21527 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21528 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21529 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21530 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21531 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21532 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21533 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21534 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21535 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21536 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21537 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21538 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21539 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21540 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21541 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21542 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21543 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21544 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21545 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21546 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21547 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21548 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21549 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21550 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21551 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21552 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21553 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       143
21554 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mktyv
21555 
21556 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mktyv
21557 
21558   /* The residual arity for this instruction does not depend on fast labels. */
21559   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21560 
21561 
21562 #if defined (JITTER_PROFILE_SAMPLE)
21563   JITTER_PROFILE_SAMPLE_UPDATE
21564      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21565       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21566   /* Force the compiler not move sample-profiling instrumentation
21567      beyond this point; this way the actual user code is timed.
21568      This is still not perfect, as residuals are materialised before
21569      we arrive here, but should be adequate at least for slow VM
21570      instructions. */
21571   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21572 #endif
21573 #if defined (JITTER_PROFILE_COUNT)
21574   /* Notice that, differently from the code above, this
21575      instrumentation code *can* be reordered freely: as long as a
21576      VM instruction is counted, the count increment can be placed
21577      anyehere.  Let GCC move this code and possibly achieve better
21578      throughput by exploiting instruction-level parallelism and
21579      therefore approximate more closely a non-profiled build. */
21580   JITTER_PROFILE_COUNT_UPDATE
21581      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21582       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21583 #endif
21584 
21585 /* User-specified code, instruction-beginning-c part: beginning. */
21586 
21587 /* User-specified code, instruction-beginning-c part: end */
21588 
21589 
21590     /* User code for mktyv . */
21591 #line 5031 "../../libpoke/pvm.jitter"
21592 
21593     JITTER_PUSH_STACK (pvm_make_void_type ());
21594 
21595     /* End of the user code for mktyv . */
21596 
21597 /* User-specified code, instruction-end-c part: beginning. */
21598 
21599 /* User-specified code, instruction-end-c part: end */
21600 
21601     /* Undefine the mktyv argument macros so they can't be used
21602        by mistake in the instruction body coming next. */
21603 
21604 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21605 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21606 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21607 
21608   }
21609  JITTER_INSTRUCTION_EPILOG_(mktyv, mktyv, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21610 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21611 
21612   JITTER_INSTRUCTION_PROLOG_(mm, mm, hot)
21613   {
21614     /* This specialized instruction is not a replacement. */
21615 #   undef JITTER_BRANCH_FAST
21616 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21617 #   undef JITTER_BRANCH_FAST_IF_ZERO
21618 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21619 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21620 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21621 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21622 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21623 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21624 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21625 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21626 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21627 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21628 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21629 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21630 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21631 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21632 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21633 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21634 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21635 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21636 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21637 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21638 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21639 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21640 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21641 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21642 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21643 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21644 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21645 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21646 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21647 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21648 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21649 #   undef JITTER_BRANCH_FAST_IF_AND
21650 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21651 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21652 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21653 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21654 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21655 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21656 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21657 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21658 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21659 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21660 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21661 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21662 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21663 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21664 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21665 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21666 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21667 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21668 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21669 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21670 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21671 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21672 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21673 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21674 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21675 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21676 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21677 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21678 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21679 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       144
21680 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mm
21681 
21682 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mm
21683 
21684   /* The residual arity for this instruction does not depend on fast labels. */
21685   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21686 
21687 
21688 #if defined (JITTER_PROFILE_SAMPLE)
21689   JITTER_PROFILE_SAMPLE_UPDATE
21690      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21691       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21692   /* Force the compiler not move sample-profiling instrumentation
21693      beyond this point; this way the actual user code is timed.
21694      This is still not perfect, as residuals are materialised before
21695      we arrive here, but should be adequate at least for slow VM
21696      instructions. */
21697   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21698 #endif
21699 #if defined (JITTER_PROFILE_COUNT)
21700   /* Notice that, differently from the code above, this
21701      instrumentation code *can* be reordered freely: as long as a
21702      VM instruction is counted, the count increment can be placed
21703      anyehere.  Let GCC move this code and possibly achieve better
21704      throughput by exploiting instruction-level parallelism and
21705      therefore approximate more closely a non-profiled build. */
21706   JITTER_PROFILE_COUNT_UPDATE
21707      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21708       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21709 #endif
21710 
21711 /* User-specified code, instruction-beginning-c part: beginning. */
21712 
21713 /* User-specified code, instruction-beginning-c part: end */
21714 
21715 
21716     /* User code for mm . */
21717 #line 4665 "../../libpoke/pvm.jitter"
21718 
21719     pvm_val mapped_p = PVM_MAKE_INT (PVM_VAL_MAPPED_P (JITTER_TOP_STACK ()),
21720                                      32);
21721     JITTER_PUSH_STACK (mapped_p);
21722 
21723     /* End of the user code for mm . */
21724 
21725 /* User-specified code, instruction-end-c part: beginning. */
21726 
21727 /* User-specified code, instruction-end-c part: end */
21728 
21729     /* Undefine the mm argument macros so they can't be used
21730        by mistake in the instruction body coming next. */
21731 
21732 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21733 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21734 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21735 
21736   }
21737  JITTER_INSTRUCTION_EPILOG_(mm, mm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21738 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21739 
21740   JITTER_INSTRUCTION_PROLOG_(modi, modi, hot)
21741   {
21742     /* This specialized instruction is not a replacement. */
21743 #   undef JITTER_BRANCH_FAST
21744 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21745 #   undef JITTER_BRANCH_FAST_IF_ZERO
21746 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21747 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21748 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21749 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21750 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21751 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21752 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21753 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21754 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21755 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21756 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21757 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21758 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21759 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21760 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21761 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21762 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21763 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21764 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21765 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21766 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21767 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21768 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21769 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21770 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21771 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21772 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21773 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21774 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21775 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21776 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21777 #   undef JITTER_BRANCH_FAST_IF_AND
21778 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21779 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21780 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21781 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21782 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21783 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21784 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21785 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21786 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21787 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21788 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21789 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21790 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21791 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21792 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21793 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21794 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21795 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21796 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21797 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21798 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21799 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21800 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21801 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21802 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21803 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21804 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21805 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21806 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21807 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       145
21808 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         modi
21809 
21810 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME modi
21811 
21812   /* The residual arity for this instruction does not depend on fast labels. */
21813   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21814 
21815 
21816 #if defined (JITTER_PROFILE_SAMPLE)
21817   JITTER_PROFILE_SAMPLE_UPDATE
21818      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21819       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21820   /* Force the compiler not move sample-profiling instrumentation
21821      beyond this point; this way the actual user code is timed.
21822      This is still not perfect, as residuals are materialised before
21823      we arrive here, but should be adequate at least for slow VM
21824      instructions. */
21825   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21826 #endif
21827 #if defined (JITTER_PROFILE_COUNT)
21828   /* Notice that, differently from the code above, this
21829      instrumentation code *can* be reordered freely: as long as a
21830      VM instruction is counted, the count increment can be placed
21831      anyehere.  Let GCC move this code and possibly achieve better
21832      throughput by exploiting instruction-level parallelism and
21833      therefore approximate more closely a non-profiled build. */
21834   JITTER_PROFILE_COUNT_UPDATE
21835      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21836       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21837 #endif
21838 
21839 /* User-specified code, instruction-beginning-c part: beginning. */
21840 
21841 /* User-specified code, instruction-beginning-c part: end */
21842 
21843 
21844     /* User code for modi . */
21845 #line 2514 "../../libpoke/pvm.jitter"
21846 
21847     PVM_MOD_SIGNED (INT, int);
21848 
21849     /* End of the user code for modi . */
21850 
21851 /* User-specified code, instruction-end-c part: beginning. */
21852 
21853 /* User-specified code, instruction-end-c part: end */
21854 
21855     /* Undefine the modi argument macros so they can't be used
21856        by mistake in the instruction body coming next. */
21857 
21858 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21859 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21860 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21861 
21862   }
21863  JITTER_INSTRUCTION_EPILOG_(modi, modi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21864 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21865 
21866   JITTER_INSTRUCTION_PROLOG_(modiu, modiu, hot)
21867   {
21868     /* This specialized instruction is not a replacement. */
21869 #   undef JITTER_BRANCH_FAST
21870 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21871 #   undef JITTER_BRANCH_FAST_IF_ZERO
21872 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21873 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21874 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21875 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21876 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21877 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21878 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21879 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21880 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21881 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21882 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21883 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21884 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21885 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21886 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21887 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21888 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21889 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21890 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21891 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21892 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21893 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21894 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21895 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21896 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21897 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21898 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21899 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21900 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21901 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21902 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21903 #   undef JITTER_BRANCH_FAST_IF_AND
21904 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21905 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21906 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21907 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21908 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21909 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21910 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21911 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21912 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21913 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21914 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21915 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21916 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21917 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21918 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21919 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21920 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21921 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21922 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21923 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21924 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21925 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21926 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21927 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21928 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21929 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21930 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21931 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21932 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21933 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       146
21934 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         modiu
21935 
21936 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME modiu
21937 
21938   /* The residual arity for this instruction does not depend on fast labels. */
21939   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21940 
21941 
21942 #if defined (JITTER_PROFILE_SAMPLE)
21943   JITTER_PROFILE_SAMPLE_UPDATE
21944      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21945       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21946   /* Force the compiler not move sample-profiling instrumentation
21947      beyond this point; this way the actual user code is timed.
21948      This is still not perfect, as residuals are materialised before
21949      we arrive here, but should be adequate at least for slow VM
21950      instructions. */
21951   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21952 #endif
21953 #if defined (JITTER_PROFILE_COUNT)
21954   /* Notice that, differently from the code above, this
21955      instrumentation code *can* be reordered freely: as long as a
21956      VM instruction is counted, the count increment can be placed
21957      anyehere.  Let GCC move this code and possibly achieve better
21958      throughput by exploiting instruction-level parallelism and
21959      therefore approximate more closely a non-profiled build. */
21960   JITTER_PROFILE_COUNT_UPDATE
21961      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21962       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21963 #endif
21964 
21965 /* User-specified code, instruction-beginning-c part: beginning. */
21966 
21967 /* User-specified code, instruction-beginning-c part: end */
21968 
21969 
21970     /* User code for modiu . */
21971 #line 2529 "../../libpoke/pvm.jitter"
21972 
21973     PVM_CHECKED_BINOP (UINT, UINT, UINT, %);
21974 
21975     /* End of the user code for modiu . */
21976 
21977 /* User-specified code, instruction-end-c part: beginning. */
21978 
21979 /* User-specified code, instruction-end-c part: end */
21980 
21981     /* Undefine the modiu argument macros so they can't be used
21982        by mistake in the instruction body coming next. */
21983 
21984 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21985 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21986 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21987 
21988   }
21989  JITTER_INSTRUCTION_EPILOG_(modiu, modiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21990 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21991 
21992   JITTER_INSTRUCTION_PROLOG_(modl, modl, hot)
21993   {
21994     /* This specialized instruction is not a replacement. */
21995 #   undef JITTER_BRANCH_FAST
21996 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21997 #   undef JITTER_BRANCH_FAST_IF_ZERO
21998 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21999 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22000 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22001 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22002 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22003 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22004 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22005 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22006 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22007 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22008 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22009 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22010 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22011 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22012 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22013 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22014 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22015 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22016 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22017 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22018 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22019 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22020 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22021 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22022 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22023 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22024 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22025 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22026 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22027 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22028 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22029 #   undef JITTER_BRANCH_FAST_IF_AND
22030 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22031 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22032 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22033 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22034 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22035 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22036 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22037 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22038 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22039 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22040 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22041 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22042 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22043 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22044 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22045 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22046 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22047 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22048 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22049 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22050 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22051 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22052 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22053 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22054 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22055 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22056 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22057 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22058 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22059 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       147
22060 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         modl
22061 
22062 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME modl
22063 
22064   /* The residual arity for this instruction does not depend on fast labels. */
22065   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22066 
22067 
22068 #if defined (JITTER_PROFILE_SAMPLE)
22069   JITTER_PROFILE_SAMPLE_UPDATE
22070      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22071       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22072   /* Force the compiler not move sample-profiling instrumentation
22073      beyond this point; this way the actual user code is timed.
22074      This is still not perfect, as residuals are materialised before
22075      we arrive here, but should be adequate at least for slow VM
22076      instructions. */
22077   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22078 #endif
22079 #if defined (JITTER_PROFILE_COUNT)
22080   /* Notice that, differently from the code above, this
22081      instrumentation code *can* be reordered freely: as long as a
22082      VM instruction is counted, the count increment can be placed
22083      anyehere.  Let GCC move this code and possibly achieve better
22084      throughput by exploiting instruction-level parallelism and
22085      therefore approximate more closely a non-profiled build. */
22086   JITTER_PROFILE_COUNT_UPDATE
22087      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22088       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22089 #endif
22090 
22091 /* User-specified code, instruction-beginning-c part: beginning. */
22092 
22093 /* User-specified code, instruction-beginning-c part: end */
22094 
22095 
22096     /* User code for modl . */
22097 #line 2543 "../../libpoke/pvm.jitter"
22098 
22099     PVM_MOD_SIGNED (LONG, int64_t);
22100 
22101     /* End of the user code for modl . */
22102 
22103 /* User-specified code, instruction-end-c part: beginning. */
22104 
22105 /* User-specified code, instruction-end-c part: end */
22106 
22107     /* Undefine the modl argument macros so they can't be used
22108        by mistake in the instruction body coming next. */
22109 
22110 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22111 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22112 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22113 
22114   }
22115  JITTER_INSTRUCTION_EPILOG_(modl, modl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22116 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22117 
22118   JITTER_INSTRUCTION_PROLOG_(modlu, modlu, hot)
22119   {
22120     /* This specialized instruction is not a replacement. */
22121 #   undef JITTER_BRANCH_FAST
22122 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22123 #   undef JITTER_BRANCH_FAST_IF_ZERO
22124 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22125 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22126 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22127 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22128 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22129 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22130 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22131 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22132 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22133 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22134 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22135 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22136 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22137 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22138 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22139 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22140 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22141 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22142 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22143 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22144 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22145 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22146 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22147 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22148 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22149 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22150 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22151 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22152 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22153 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22154 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22155 #   undef JITTER_BRANCH_FAST_IF_AND
22156 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22157 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22158 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22159 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22160 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22161 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22162 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22163 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22164 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22165 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22166 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22167 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22168 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22169 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22170 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22171 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22172 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22173 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22174 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22175 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22176 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22177 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22178 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22179 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22180 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22181 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22182 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22183 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22184 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22185 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       148
22186 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         modlu
22187 
22188 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME modlu
22189 
22190   /* The residual arity for this instruction does not depend on fast labels. */
22191   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22192 
22193 
22194 #if defined (JITTER_PROFILE_SAMPLE)
22195   JITTER_PROFILE_SAMPLE_UPDATE
22196      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22197       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22198   /* Force the compiler not move sample-profiling instrumentation
22199      beyond this point; this way the actual user code is timed.
22200      This is still not perfect, as residuals are materialised before
22201      we arrive here, but should be adequate at least for slow VM
22202      instructions. */
22203   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22204 #endif
22205 #if defined (JITTER_PROFILE_COUNT)
22206   /* Notice that, differently from the code above, this
22207      instrumentation code *can* be reordered freely: as long as a
22208      VM instruction is counted, the count increment can be placed
22209      anyehere.  Let GCC move this code and possibly achieve better
22210      throughput by exploiting instruction-level parallelism and
22211      therefore approximate more closely a non-profiled build. */
22212   JITTER_PROFILE_COUNT_UPDATE
22213      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22214       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22215 #endif
22216 
22217 /* User-specified code, instruction-beginning-c part: beginning. */
22218 
22219 /* User-specified code, instruction-beginning-c part: end */
22220 
22221 
22222     /* User code for modlu . */
22223 #line 2557 "../../libpoke/pvm.jitter"
22224 
22225     PVM_CHECKED_BINOP (ULONG, ULONG, ULONG, %);
22226 
22227     /* End of the user code for modlu . */
22228 
22229 /* User-specified code, instruction-end-c part: beginning. */
22230 
22231 /* User-specified code, instruction-end-c part: end */
22232 
22233     /* Undefine the modlu argument macros so they can't be used
22234        by mistake in the instruction body coming next. */
22235 
22236 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22237 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22238 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22239 
22240   }
22241  JITTER_INSTRUCTION_EPILOG_(modlu, modlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22242 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22243 
22244   JITTER_INSTRUCTION_PROLOG_(msetios, msetios, hot)
22245   {
22246     /* This specialized instruction is not a replacement. */
22247 #   undef JITTER_BRANCH_FAST
22248 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22249 #   undef JITTER_BRANCH_FAST_IF_ZERO
22250 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22251 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22252 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22253 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22254 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22255 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22256 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22257 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22258 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22259 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22260 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22261 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22262 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22263 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22264 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22265 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22266 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22267 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22268 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22269 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22270 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22271 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22272 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22273 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22274 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22275 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22276 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22277 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22278 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22279 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22280 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22281 #   undef JITTER_BRANCH_FAST_IF_AND
22282 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22283 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22284 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22285 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22286 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22287 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22288 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22289 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22290 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22291 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22292 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22293 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22294 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22295 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22296 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22297 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22298 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22299 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22300 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22301 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22302 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22303 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22304 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22305 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22306 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22307 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22308 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22309 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22310 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22311 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       149
22312 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         msetios
22313 
22314 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME msetios
22315 
22316   /* The residual arity for this instruction does not depend on fast labels. */
22317   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22318 
22319 
22320 #if defined (JITTER_PROFILE_SAMPLE)
22321   JITTER_PROFILE_SAMPLE_UPDATE
22322      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22323       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22324   /* Force the compiler not move sample-profiling instrumentation
22325      beyond this point; this way the actual user code is timed.
22326      This is still not perfect, as residuals are materialised before
22327      we arrive here, but should be adequate at least for slow VM
22328      instructions. */
22329   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22330 #endif
22331 #if defined (JITTER_PROFILE_COUNT)
22332   /* Notice that, differently from the code above, this
22333      instrumentation code *can* be reordered freely: as long as a
22334      VM instruction is counted, the count increment can be placed
22335      anyehere.  Let GCC move this code and possibly achieve better
22336      throughput by exploiting instruction-level parallelism and
22337      therefore approximate more closely a non-profiled build. */
22338   JITTER_PROFILE_COUNT_UPDATE
22339      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22340       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22341 #endif
22342 
22343 /* User-specified code, instruction-beginning-c part: beginning. */
22344 
22345 /* User-specified code, instruction-beginning-c part: end */
22346 
22347 
22348     /* User code for msetios . */
22349 #line 4836 "../../libpoke/pvm.jitter"
22350 
22351     PVM_VAL_SET_IOS (JITTER_UNDER_TOP_STACK (),
22352                      JITTER_TOP_STACK ());
22353     JITTER_DROP_STACK ();
22354 
22355     /* End of the user code for msetios . */
22356 
22357 /* User-specified code, instruction-end-c part: beginning. */
22358 
22359 /* User-specified code, instruction-end-c part: end */
22360 
22361     /* Undefine the msetios argument macros so they can't be used
22362        by mistake in the instruction body coming next. */
22363 
22364 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22365 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22366 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22367 
22368   }
22369  JITTER_INSTRUCTION_EPILOG_(msetios, msetios, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22370 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22371 
22372   JITTER_INSTRUCTION_PROLOG_(msetm, msetm, hot)
22373   {
22374     /* This specialized instruction is not a replacement. */
22375 #   undef JITTER_BRANCH_FAST
22376 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22377 #   undef JITTER_BRANCH_FAST_IF_ZERO
22378 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22379 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22380 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22381 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22382 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22383 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22384 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22385 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22386 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22387 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22388 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22389 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22390 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22391 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22392 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22393 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22394 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22395 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22396 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22397 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22398 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22399 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22400 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22401 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22402 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22403 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22404 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22405 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22406 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22407 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22408 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22409 #   undef JITTER_BRANCH_FAST_IF_AND
22410 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22411 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22412 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22413 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22414 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22415 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22416 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22417 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22418 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22419 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22420 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22421 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22422 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22423 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22424 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22425 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22426 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22427 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22428 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22429 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22430 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22431 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22432 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22433 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22434 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22435 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22436 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22437 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22438 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22439 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       150
22440 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         msetm
22441 
22442 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME msetm
22443 
22444   /* The residual arity for this instruction does not depend on fast labels. */
22445   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22446 
22447 
22448 #if defined (JITTER_PROFILE_SAMPLE)
22449   JITTER_PROFILE_SAMPLE_UPDATE
22450      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22451       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22452   /* Force the compiler not move sample-profiling instrumentation
22453      beyond this point; this way the actual user code is timed.
22454      This is still not perfect, as residuals are materialised before
22455      we arrive here, but should be adequate at least for slow VM
22456      instructions. */
22457   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22458 #endif
22459 #if defined (JITTER_PROFILE_COUNT)
22460   /* Notice that, differently from the code above, this
22461      instrumentation code *can* be reordered freely: as long as a
22462      VM instruction is counted, the count increment can be placed
22463      anyehere.  Let GCC move this code and possibly achieve better
22464      throughput by exploiting instruction-level parallelism and
22465      therefore approximate more closely a non-profiled build. */
22466   JITTER_PROFILE_COUNT_UPDATE
22467      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22468       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22469 #endif
22470 
22471 /* User-specified code, instruction-beginning-c part: beginning. */
22472 
22473 /* User-specified code, instruction-beginning-c part: end */
22474 
22475 
22476     /* User code for msetm . */
22477 #line 4864 "../../libpoke/pvm.jitter"
22478 
22479     PVM_VAL_SET_MAPPER (JITTER_UNDER_TOP_STACK (), JITTER_TOP_STACK ());
22480     JITTER_DROP_STACK ();
22481 
22482     /* End of the user code for msetm . */
22483 
22484 /* User-specified code, instruction-end-c part: beginning. */
22485 
22486 /* User-specified code, instruction-end-c part: end */
22487 
22488     /* Undefine the msetm argument macros so they can't be used
22489        by mistake in the instruction body coming next. */
22490 
22491 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22492 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22493 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22494 
22495   }
22496  JITTER_INSTRUCTION_EPILOG_(msetm, msetm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22497 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22498 
22499   JITTER_INSTRUCTION_PROLOG_(mseto, mseto, hot)
22500   {
22501     /* This specialized instruction is not a replacement. */
22502 #   undef JITTER_BRANCH_FAST
22503 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22504 #   undef JITTER_BRANCH_FAST_IF_ZERO
22505 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22506 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22507 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22508 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22509 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22510 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22511 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22512 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22513 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22514 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22515 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22516 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22517 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22518 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22519 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22520 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22521 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22522 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22523 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22524 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22525 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22526 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22527 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22528 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22529 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22530 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22531 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22532 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22533 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22534 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22535 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22536 #   undef JITTER_BRANCH_FAST_IF_AND
22537 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22538 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22539 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22540 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22541 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22542 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22543 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22544 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22545 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22546 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22547 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22548 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22549 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22550 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22551 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22552 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22553 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22554 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22555 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22556 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22557 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22558 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22559 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22560 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22561 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22562 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22563 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22564 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22565 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22566 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       151
22567 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mseto
22568 
22569 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mseto
22570 
22571   /* The residual arity for this instruction does not depend on fast labels. */
22572   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22573 
22574 
22575 #if defined (JITTER_PROFILE_SAMPLE)
22576   JITTER_PROFILE_SAMPLE_UPDATE
22577      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22578       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22579   /* Force the compiler not move sample-profiling instrumentation
22580      beyond this point; this way the actual user code is timed.
22581      This is still not perfect, as residuals are materialised before
22582      we arrive here, but should be adequate at least for slow VM
22583      instructions. */
22584   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22585 #endif
22586 #if defined (JITTER_PROFILE_COUNT)
22587   /* Notice that, differently from the code above, this
22588      instrumentation code *can* be reordered freely: as long as a
22589      VM instruction is counted, the count increment can be placed
22590      anyehere.  Let GCC move this code and possibly achieve better
22591      throughput by exploiting instruction-level parallelism and
22592      therefore approximate more closely a non-profiled build. */
22593   JITTER_PROFILE_COUNT_UPDATE
22594      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22595       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22596 #endif
22597 
22598 /* User-specified code, instruction-beginning-c part: beginning. */
22599 
22600 /* User-specified code, instruction-beginning-c part: end */
22601 
22602 
22603     /* User code for mseto . */
22604 #line 4806 "../../libpoke/pvm.jitter"
22605 
22606     PVM_VAL_SET_OFFSET (JITTER_UNDER_TOP_STACK (),
22607                         JITTER_TOP_STACK ());
22608     JITTER_DROP_STACK ();
22609 
22610     /* End of the user code for mseto . */
22611 
22612 /* User-specified code, instruction-end-c part: beginning. */
22613 
22614 /* User-specified code, instruction-end-c part: end */
22615 
22616     /* Undefine the mseto argument macros so they can't be used
22617        by mistake in the instruction body coming next. */
22618 
22619 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22620 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22621 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22622 
22623   }
22624  JITTER_INSTRUCTION_EPILOG_(mseto, mseto, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22625 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22626 
22627   JITTER_INSTRUCTION_PROLOG_(msets, msets, hot)
22628   {
22629     /* This specialized instruction is not a replacement. */
22630 #   undef JITTER_BRANCH_FAST
22631 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22632 #   undef JITTER_BRANCH_FAST_IF_ZERO
22633 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22634 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22635 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22636 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22637 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22638 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22639 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22640 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22641 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22642 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22643 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22644 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22645 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22646 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22647 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22648 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22649 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22650 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22651 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22652 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22653 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22654 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22655 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22656 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22657 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22658 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22659 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22660 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22661 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22662 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22663 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22664 #   undef JITTER_BRANCH_FAST_IF_AND
22665 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22666 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22667 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22668 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22669 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22670 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22671 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22672 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22673 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22674 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22675 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22676 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22677 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22678 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22679 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22680 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22681 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22682 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22683 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22684 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22685 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22686 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22687 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22688 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22689 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22690 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22691 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22692 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22693 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22694 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       152
22695 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         msets
22696 
22697 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME msets
22698 
22699   /* The residual arity for this instruction does not depend on fast labels. */
22700   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22701 
22702 
22703 #if defined (JITTER_PROFILE_SAMPLE)
22704   JITTER_PROFILE_SAMPLE_UPDATE
22705      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22706       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22707   /* Force the compiler not move sample-profiling instrumentation
22708      beyond this point; this way the actual user code is timed.
22709      This is still not perfect, as residuals are materialised before
22710      we arrive here, but should be adequate at least for slow VM
22711      instructions. */
22712   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22713 #endif
22714 #if defined (JITTER_PROFILE_COUNT)
22715   /* Notice that, differently from the code above, this
22716      instrumentation code *can* be reordered freely: as long as a
22717      VM instruction is counted, the count increment can be placed
22718      anyehere.  Let GCC move this code and possibly achieve better
22719      throughput by exploiting instruction-level parallelism and
22720      therefore approximate more closely a non-profiled build. */
22721   JITTER_PROFILE_COUNT_UPDATE
22722      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22723       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22724 #endif
22725 
22726 /* User-specified code, instruction-beginning-c part: beginning. */
22727 
22728 /* User-specified code, instruction-beginning-c part: end */
22729 
22730 
22731     /* User code for msets . */
22732 #line 4776 "../../libpoke/pvm.jitter"
22733 
22734     int strict_p = PVM_VAL_INT (JITTER_TOP_STACK ());
22735 
22736     PVM_VAL_SET_STRICT_P (JITTER_UNDER_TOP_STACK (), strict_p);
22737     JITTER_DROP_STACK ();
22738 
22739     /* End of the user code for msets . */
22740 
22741 /* User-specified code, instruction-end-c part: beginning. */
22742 
22743 /* User-specified code, instruction-end-c part: end */
22744 
22745     /* Undefine the msets argument macros so they can't be used
22746        by mistake in the instruction body coming next. */
22747 
22748 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22749 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22750 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22751 
22752   }
22753  JITTER_INSTRUCTION_EPILOG_(msets, msets, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22754 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22755 
22756   JITTER_INSTRUCTION_PROLOG_(msetsel, msetsel, hot)
22757   {
22758     /* This specialized instruction is not a replacement. */
22759 #   undef JITTER_BRANCH_FAST
22760 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22761 #   undef JITTER_BRANCH_FAST_IF_ZERO
22762 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22763 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22764 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22765 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22766 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22767 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22768 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22769 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22770 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22771 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22772 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22773 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22774 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22775 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22776 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22777 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22778 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22779 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22780 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22781 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22782 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22783 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22784 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22785 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22786 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22787 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22788 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22789 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22790 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22791 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22792 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22793 #   undef JITTER_BRANCH_FAST_IF_AND
22794 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22795 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22796 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22797 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22798 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22799 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22800 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22801 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22802 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22803 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22804 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22805 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22806 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22807 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22808 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22809 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22810 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22811 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22812 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22813 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22814 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22815 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22816 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22817 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22818 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22819 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22820 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22821 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22822 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22823 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       153
22824 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         msetsel
22825 
22826 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME msetsel
22827 
22828   /* The residual arity for this instruction does not depend on fast labels. */
22829   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22830 
22831 
22832 #if defined (JITTER_PROFILE_SAMPLE)
22833   JITTER_PROFILE_SAMPLE_UPDATE
22834      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22835       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22836   /* Force the compiler not move sample-profiling instrumentation
22837      beyond this point; this way the actual user code is timed.
22838      This is still not perfect, as residuals are materialised before
22839      we arrive here, but should be adequate at least for slow VM
22840      instructions. */
22841   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22842 #endif
22843 #if defined (JITTER_PROFILE_COUNT)
22844   /* Notice that, differently from the code above, this
22845      instrumentation code *can* be reordered freely: as long as a
22846      VM instruction is counted, the count increment can be placed
22847      anyehere.  Let GCC move this code and possibly achieve better
22848      throughput by exploiting instruction-level parallelism and
22849      therefore approximate more closely a non-profiled build. */
22850   JITTER_PROFILE_COUNT_UPDATE
22851      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22852       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22853 #endif
22854 
22855 /* User-specified code, instruction-beginning-c part: beginning. */
22856 
22857 /* User-specified code, instruction-beginning-c part: end */
22858 
22859 
22860     /* User code for msetsel . */
22861 #line 4926 "../../libpoke/pvm.jitter"
22862 
22863     PVM_VAL_SET_ELEMS_BOUND (JITTER_UNDER_TOP_STACK (), JITTER_TOP_STACK ());
22864     JITTER_DROP_STACK ();
22865 
22866     /* End of the user code for msetsel . */
22867 
22868 /* User-specified code, instruction-end-c part: beginning. */
22869 
22870 /* User-specified code, instruction-end-c part: end */
22871 
22872     /* Undefine the msetsel argument macros so they can't be used
22873        by mistake in the instruction body coming next. */
22874 
22875 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22876 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22877 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22878 
22879   }
22880  JITTER_INSTRUCTION_EPILOG_(msetsel, msetsel, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22881 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22882 
22883   JITTER_INSTRUCTION_PROLOG_(msetsiz, msetsiz, hot)
22884   {
22885     /* This specialized instruction is not a replacement. */
22886 #   undef JITTER_BRANCH_FAST
22887 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22888 #   undef JITTER_BRANCH_FAST_IF_ZERO
22889 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22890 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22891 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22892 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22893 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22894 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22895 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22896 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22897 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22898 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22899 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22900 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22901 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22902 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22903 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22904 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22905 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22906 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22907 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22908 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22909 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22910 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22911 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22912 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22913 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22914 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22915 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22916 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22917 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22918 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22919 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22920 #   undef JITTER_BRANCH_FAST_IF_AND
22921 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22922 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22923 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22924 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22925 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22926 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22927 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22928 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22929 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22930 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22931 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22932 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22933 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22934 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22935 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22936 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22937 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22938 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22939 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22940 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22941 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22942 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22943 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22944 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22945 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22946 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22947 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22948 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22949 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22950 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       154
22951 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         msetsiz
22952 
22953 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME msetsiz
22954 
22955   /* The residual arity for this instruction does not depend on fast labels. */
22956   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22957 
22958 
22959 #if defined (JITTER_PROFILE_SAMPLE)
22960   JITTER_PROFILE_SAMPLE_UPDATE
22961      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22962       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22963   /* Force the compiler not move sample-profiling instrumentation
22964      beyond this point; this way the actual user code is timed.
22965      This is still not perfect, as residuals are materialised before
22966      we arrive here, but should be adequate at least for slow VM
22967      instructions. */
22968   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22969 #endif
22970 #if defined (JITTER_PROFILE_COUNT)
22971   /* Notice that, differently from the code above, this
22972      instrumentation code *can* be reordered freely: as long as a
22973      VM instruction is counted, the count increment can be placed
22974      anyehere.  Let GCC move this code and possibly achieve better
22975      throughput by exploiting instruction-level parallelism and
22976      therefore approximate more closely a non-profiled build. */
22977   JITTER_PROFILE_COUNT_UPDATE
22978      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22979       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22980 #endif
22981 
22982 /* User-specified code, instruction-beginning-c part: beginning. */
22983 
22984 /* User-specified code, instruction-beginning-c part: end */
22985 
22986 
22987     /* User code for msetsiz . */
22988 #line 4959 "../../libpoke/pvm.jitter"
22989 
22990     PVM_VAL_SET_SIZE_BOUND (JITTER_UNDER_TOP_STACK (), JITTER_TOP_STACK ());
22991     JITTER_DROP_STACK ();
22992 
22993     /* End of the user code for msetsiz . */
22994 
22995 /* User-specified code, instruction-end-c part: beginning. */
22996 
22997 /* User-specified code, instruction-end-c part: end */
22998 
22999     /* Undefine the msetsiz argument macros so they can't be used
23000        by mistake in the instruction body coming next. */
23001 
23002 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23003 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23004 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23005 
23006   }
23007  JITTER_INSTRUCTION_EPILOG_(msetsiz, msetsiz, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23008 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23009 
23010   JITTER_INSTRUCTION_PROLOG_(msetw, msetw, hot)
23011   {
23012     /* This specialized instruction is not a replacement. */
23013 #   undef JITTER_BRANCH_FAST
23014 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23015 #   undef JITTER_BRANCH_FAST_IF_ZERO
23016 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23017 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23018 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23019 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23020 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23021 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23022 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23023 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23024 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23025 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23026 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23027 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23028 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23029 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23030 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23031 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23032 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23033 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23034 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23035 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23036 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23037 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23038 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23039 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23040 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23041 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23042 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23043 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23044 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23045 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23046 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23047 #   undef JITTER_BRANCH_FAST_IF_AND
23048 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23049 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23050 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23051 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23052 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23053 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23054 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23055 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23056 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23057 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23058 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23059 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23060 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23061 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23062 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23063 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23064 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23065 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23066 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23067 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23068 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23069 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23070 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23071 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23072 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23073 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23074 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23075 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23076 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23077 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       155
23078 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         msetw
23079 
23080 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME msetw
23081 
23082   /* The residual arity for this instruction does not depend on fast labels. */
23083   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23084 
23085 
23086 #if defined (JITTER_PROFILE_SAMPLE)
23087   JITTER_PROFILE_SAMPLE_UPDATE
23088      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23089       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23090   /* Force the compiler not move sample-profiling instrumentation
23091      beyond this point; this way the actual user code is timed.
23092      This is still not perfect, as residuals are materialised before
23093      we arrive here, but should be adequate at least for slow VM
23094      instructions. */
23095   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23096 #endif
23097 #if defined (JITTER_PROFILE_COUNT)
23098   /* Notice that, differently from the code above, this
23099      instrumentation code *can* be reordered freely: as long as a
23100      VM instruction is counted, the count increment can be placed
23101      anyehere.  Let GCC move this code and possibly achieve better
23102      throughput by exploiting instruction-level parallelism and
23103      therefore approximate more closely a non-profiled build. */
23104   JITTER_PROFILE_COUNT_UPDATE
23105      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23106       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23107 #endif
23108 
23109 /* User-specified code, instruction-beginning-c part: beginning. */
23110 
23111 /* User-specified code, instruction-beginning-c part: end */
23112 
23113 
23114     /* User code for msetw . */
23115 #line 4891 "../../libpoke/pvm.jitter"
23116 
23117     PVM_VAL_SET_WRITER (JITTER_UNDER_TOP_STACK (), JITTER_TOP_STACK ());
23118     JITTER_DROP_STACK ();
23119 
23120     /* End of the user code for msetw . */
23121 
23122 /* User-specified code, instruction-end-c part: beginning. */
23123 
23124 /* User-specified code, instruction-end-c part: end */
23125 
23126     /* Undefine the msetw argument macros so they can't be used
23127        by mistake in the instruction body coming next. */
23128 
23129 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23130 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23131 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23132 
23133   }
23134  JITTER_INSTRUCTION_EPILOG_(msetw, msetw, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23135 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23136 
23137   JITTER_INSTRUCTION_PROLOG_(muli, muli, hot)
23138   {
23139     /* This specialized instruction is not a replacement. */
23140 #   undef JITTER_BRANCH_FAST
23141 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23142 #   undef JITTER_BRANCH_FAST_IF_ZERO
23143 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23144 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23145 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23146 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23147 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23148 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23149 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23150 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23151 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23152 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23153 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23154 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23155 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23156 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23157 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23158 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23159 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23160 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23161 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23162 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23163 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23164 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23165 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23166 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23167 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23168 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23169 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23170 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23171 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23172 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23173 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23174 #   undef JITTER_BRANCH_FAST_IF_AND
23175 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23176 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23177 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23178 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23179 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23180 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23181 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23182 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23183 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23184 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23185 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23186 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23187 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23188 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23189 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23190 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23191 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23192 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23193 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23194 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23195 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23196 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23197 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23198 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23199 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23200 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23201 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23202 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23203 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23204 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       156
23205 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         muli
23206 
23207 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME muli
23208 
23209   /* The residual arity for this instruction does not depend on fast labels. */
23210   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23211 
23212 
23213 #if defined (JITTER_PROFILE_SAMPLE)
23214   JITTER_PROFILE_SAMPLE_UPDATE
23215      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23216       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23217   /* Force the compiler not move sample-profiling instrumentation
23218      beyond this point; this way the actual user code is timed.
23219      This is still not perfect, as residuals are materialised before
23220      we arrive here, but should be adequate at least for slow VM
23221      instructions. */
23222   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23223 #endif
23224 #if defined (JITTER_PROFILE_COUNT)
23225   /* Notice that, differently from the code above, this
23226      instrumentation code *can* be reordered freely: as long as a
23227      VM instruction is counted, the count increment can be placed
23228      anyehere.  Let GCC move this code and possibly achieve better
23229      throughput by exploiting instruction-level parallelism and
23230      therefore approximate more closely a non-profiled build. */
23231   JITTER_PROFILE_COUNT_UPDATE
23232      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23233       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23234 #endif
23235 
23236 /* User-specified code, instruction-beginning-c part: beginning. */
23237 
23238 /* User-specified code, instruction-beginning-c part: end */
23239 
23240 
23241     /* User code for muli . */
23242 #line 2402 "../../libpoke/pvm.jitter"
23243 
23244     PVM_MUL_SIGNED (INT, int);
23245 
23246     /* End of the user code for muli . */
23247 
23248 /* User-specified code, instruction-end-c part: beginning. */
23249 
23250 /* User-specified code, instruction-end-c part: end */
23251 
23252     /* Undefine the muli argument macros so they can't be used
23253        by mistake in the instruction body coming next. */
23254 
23255 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23256 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23257 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23258 
23259   }
23260  JITTER_INSTRUCTION_EPILOG_(muli, muli, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23261 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23262 
23263   JITTER_INSTRUCTION_PROLOG_(muliu, muliu, hot)
23264   {
23265     /* This specialized instruction is not a replacement. */
23266 #   undef JITTER_BRANCH_FAST
23267 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23268 #   undef JITTER_BRANCH_FAST_IF_ZERO
23269 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23270 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23271 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23272 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23273 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23274 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23275 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23276 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23277 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23278 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23279 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23280 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23281 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23282 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23283 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23284 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23285 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23286 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23287 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23288 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23289 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23290 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23291 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23292 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23293 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23294 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23295 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23296 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23297 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23298 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23299 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23300 #   undef JITTER_BRANCH_FAST_IF_AND
23301 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23302 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23303 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23304 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23305 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23306 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23307 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23308 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23309 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23310 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23311 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23312 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23313 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23314 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23315 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23316 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23317 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23318 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23319 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23320 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23321 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23322 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23323 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23324 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23325 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23326 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23327 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23328 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23329 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23330 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       157
23331 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         muliu
23332 
23333 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME muliu
23334 
23335   /* The residual arity for this instruction does not depend on fast labels. */
23336   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23337 
23338 
23339 #if defined (JITTER_PROFILE_SAMPLE)
23340   JITTER_PROFILE_SAMPLE_UPDATE
23341      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23342       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23343   /* Force the compiler not move sample-profiling instrumentation
23344      beyond this point; this way the actual user code is timed.
23345      This is still not perfect, as residuals are materialised before
23346      we arrive here, but should be adequate at least for slow VM
23347      instructions. */
23348   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23349 #endif
23350 #if defined (JITTER_PROFILE_COUNT)
23351   /* Notice that, differently from the code above, this
23352      instrumentation code *can* be reordered freely: as long as a
23353      VM instruction is counted, the count increment can be placed
23354      anyehere.  Let GCC move this code and possibly achieve better
23355      throughput by exploiting instruction-level parallelism and
23356      therefore approximate more closely a non-profiled build. */
23357   JITTER_PROFILE_COUNT_UPDATE
23358      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23359       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23360 #endif
23361 
23362 /* User-specified code, instruction-beginning-c part: beginning. */
23363 
23364 /* User-specified code, instruction-beginning-c part: end */
23365 
23366 
23367     /* User code for muliu . */
23368 #line 2415 "../../libpoke/pvm.jitter"
23369 
23370     PVM_BINOP (UINT, UINT, UINT, *);
23371 
23372     /* End of the user code for muliu . */
23373 
23374 /* User-specified code, instruction-end-c part: beginning. */
23375 
23376 /* User-specified code, instruction-end-c part: end */
23377 
23378     /* Undefine the muliu argument macros so they can't be used
23379        by mistake in the instruction body coming next. */
23380 
23381 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23382 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23383 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23384 
23385   }
23386  JITTER_INSTRUCTION_EPILOG_(muliu, muliu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23387 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23388 
23389   JITTER_INSTRUCTION_PROLOG_(mull, mull, hot)
23390   {
23391     /* This specialized instruction is not a replacement. */
23392 #   undef JITTER_BRANCH_FAST
23393 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23394 #   undef JITTER_BRANCH_FAST_IF_ZERO
23395 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23396 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23397 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23398 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23399 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23400 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23401 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23402 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23403 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23404 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23405 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23406 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23407 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23408 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23409 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23410 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23411 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23412 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23413 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23414 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23415 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23416 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23417 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23418 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23419 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23420 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23421 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23422 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23423 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23424 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23425 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23426 #   undef JITTER_BRANCH_FAST_IF_AND
23427 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23428 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23429 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23430 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23431 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23432 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23433 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23434 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23435 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23436 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23437 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23438 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23439 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23440 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23441 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23442 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23443 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23444 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23445 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23446 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23447 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23448 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23449 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23450 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23451 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23452 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23453 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23454 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23455 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23456 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       158
23457 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mull
23458 
23459 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mull
23460 
23461   /* The residual arity for this instruction does not depend on fast labels. */
23462   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23463 
23464 
23465 #if defined (JITTER_PROFILE_SAMPLE)
23466   JITTER_PROFILE_SAMPLE_UPDATE
23467      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23468       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23469   /* Force the compiler not move sample-profiling instrumentation
23470      beyond this point; this way the actual user code is timed.
23471      This is still not perfect, as residuals are materialised before
23472      we arrive here, but should be adequate at least for slow VM
23473      instructions. */
23474   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23475 #endif
23476 #if defined (JITTER_PROFILE_COUNT)
23477   /* Notice that, differently from the code above, this
23478      instrumentation code *can* be reordered freely: as long as a
23479      VM instruction is counted, the count increment can be placed
23480      anyehere.  Let GCC move this code and possibly achieve better
23481      throughput by exploiting instruction-level parallelism and
23482      therefore approximate more closely a non-profiled build. */
23483   JITTER_PROFILE_COUNT_UPDATE
23484      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23485       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23486 #endif
23487 
23488 /* User-specified code, instruction-beginning-c part: beginning. */
23489 
23490 /* User-specified code, instruction-beginning-c part: end */
23491 
23492 
23493     /* User code for mull . */
23494 #line 2428 "../../libpoke/pvm.jitter"
23495 
23496     PVM_MUL_SIGNED (LONG, int64_t);
23497 
23498     /* End of the user code for mull . */
23499 
23500 /* User-specified code, instruction-end-c part: beginning. */
23501 
23502 /* User-specified code, instruction-end-c part: end */
23503 
23504     /* Undefine the mull argument macros so they can't be used
23505        by mistake in the instruction body coming next. */
23506 
23507 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23508 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23509 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23510 
23511   }
23512  JITTER_INSTRUCTION_EPILOG_(mull, mull, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23513 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23514 
23515   JITTER_INSTRUCTION_PROLOG_(mullu, mullu, hot)
23516   {
23517     /* This specialized instruction is not a replacement. */
23518 #   undef JITTER_BRANCH_FAST
23519 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23520 #   undef JITTER_BRANCH_FAST_IF_ZERO
23521 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23522 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23523 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23524 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23525 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23526 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23527 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23528 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23529 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23530 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23531 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23532 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23533 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23534 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23535 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23536 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23537 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23538 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23539 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23540 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23541 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23542 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23543 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23544 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23545 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23546 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23547 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23548 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23549 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23550 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23551 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23552 #   undef JITTER_BRANCH_FAST_IF_AND
23553 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23554 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23555 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23556 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23557 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23558 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23559 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23560 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23561 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23562 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23563 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23564 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23565 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23566 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23567 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23568 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23569 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23570 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23571 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23572 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23573 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23574 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23575 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23576 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23577 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23578 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23579 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23580 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23581 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23582 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       159
23583 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         mullu
23584 
23585 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME mullu
23586 
23587   /* The residual arity for this instruction does not depend on fast labels. */
23588   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23589 
23590 
23591 #if defined (JITTER_PROFILE_SAMPLE)
23592   JITTER_PROFILE_SAMPLE_UPDATE
23593      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23594       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23595   /* Force the compiler not move sample-profiling instrumentation
23596      beyond this point; this way the actual user code is timed.
23597      This is still not perfect, as residuals are materialised before
23598      we arrive here, but should be adequate at least for slow VM
23599      instructions. */
23600   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23601 #endif
23602 #if defined (JITTER_PROFILE_COUNT)
23603   /* Notice that, differently from the code above, this
23604      instrumentation code *can* be reordered freely: as long as a
23605      VM instruction is counted, the count increment can be placed
23606      anyehere.  Let GCC move this code and possibly achieve better
23607      throughput by exploiting instruction-level parallelism and
23608      therefore approximate more closely a non-profiled build. */
23609   JITTER_PROFILE_COUNT_UPDATE
23610      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23611       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23612 #endif
23613 
23614 /* User-specified code, instruction-beginning-c part: beginning. */
23615 
23616 /* User-specified code, instruction-beginning-c part: end */
23617 
23618 
23619     /* User code for mullu . */
23620 #line 2441 "../../libpoke/pvm.jitter"
23621 
23622     PVM_BINOP (ULONG, ULONG, ULONG, *);
23623 
23624     /* End of the user code for mullu . */
23625 
23626 /* User-specified code, instruction-end-c part: beginning. */
23627 
23628 /* User-specified code, instruction-end-c part: end */
23629 
23630     /* Undefine the mullu argument macros so they can't be used
23631        by mistake in the instruction body coming next. */
23632 
23633 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23634 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23635 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23636 
23637   }
23638  JITTER_INSTRUCTION_EPILOG_(mullu, mullu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23639 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23640 
23641   JITTER_INSTRUCTION_PROLOG_(muls, muls, hot)
23642   {
23643     /* This specialized instruction is not a replacement. */
23644 #   undef JITTER_BRANCH_FAST
23645 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23646 #   undef JITTER_BRANCH_FAST_IF_ZERO
23647 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23648 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23649 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23650 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23651 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23652 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23653 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23654 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23655 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23656 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23657 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23658 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23659 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23660 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23661 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23662 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23663 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23664 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23665 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23666 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23667 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23668 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23669 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23670 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23671 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23672 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23673 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23674 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23675 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23676 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23677 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23678 #   undef JITTER_BRANCH_FAST_IF_AND
23679 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23680 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23681 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23682 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23683 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23684 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23685 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23686 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23687 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23688 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23689 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23690 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23691 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23692 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23693 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23694 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23695 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23696 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23697 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23698 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23699 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23700 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23701 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23702 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23703 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23704 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23705 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23706 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23707 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23708 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       160
23709 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         muls
23710 
23711 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME muls
23712 
23713   /* The residual arity for this instruction does not depend on fast labels. */
23714   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23715 
23716 
23717 #if defined (JITTER_PROFILE_SAMPLE)
23718   JITTER_PROFILE_SAMPLE_UPDATE
23719      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23720       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23721   /* Force the compiler not move sample-profiling instrumentation
23722      beyond this point; this way the actual user code is timed.
23723      This is still not perfect, as residuals are materialised before
23724      we arrive here, but should be adequate at least for slow VM
23725      instructions. */
23726   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23727 #endif
23728 #if defined (JITTER_PROFILE_COUNT)
23729   /* Notice that, differently from the code above, this
23730      instrumentation code *can* be reordered freely: as long as a
23731      VM instruction is counted, the count increment can be placed
23732      anyehere.  Let GCC move this code and possibly achieve better
23733      throughput by exploiting instruction-level parallelism and
23734      therefore approximate more closely a non-profiled build. */
23735   JITTER_PROFILE_COUNT_UPDATE
23736      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23737       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23738 #endif
23739 
23740 /* User-specified code, instruction-beginning-c part: beginning. */
23741 
23742 /* User-specified code, instruction-beginning-c part: end */
23743 
23744 
23745     /* User code for muls . */
23746 #line 4072 "../../libpoke/pvm.jitter"
23747 
23748     pvm_val str = JITTER_UNDER_TOP_STACK ();
23749     size_t i, num = PVM_VAL_ULONG (JITTER_TOP_STACK ());
23750     char *res = xmalloc (strlen (PVM_VAL_STR (str)) * num + 1);
23751 
23752     *res = '\0';
23753     for (i = 0; i < num; ++i)
23754       strcat (res, PVM_VAL_STR (str));
23755 
23756     JITTER_PUSH_STACK (pvm_make_string (res));
23757     free (res);
23758 
23759     /* End of the user code for muls . */
23760 
23761 /* User-specified code, instruction-end-c part: beginning. */
23762 
23763 /* User-specified code, instruction-end-c part: end */
23764 
23765     /* Undefine the muls argument macros so they can't be used
23766        by mistake in the instruction body coming next. */
23767 
23768 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23769 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23770 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23771 
23772   }
23773  JITTER_INSTRUCTION_EPILOG_(muls, muls, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23774 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23775 
23776   JITTER_INSTRUCTION_PROLOG_(negi, negi, hot)
23777   {
23778     /* This specialized instruction is not a replacement. */
23779 #   undef JITTER_BRANCH_FAST
23780 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23781 #   undef JITTER_BRANCH_FAST_IF_ZERO
23782 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23783 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23784 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23785 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23786 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23787 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23788 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23789 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23790 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23791 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23792 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23793 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23794 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23795 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23796 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23797 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23798 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23799 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23800 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23801 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23802 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23803 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23804 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23805 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23806 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23807 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23808 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23809 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23810 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23811 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23812 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23813 #   undef JITTER_BRANCH_FAST_IF_AND
23814 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23815 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23816 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23817 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23818 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23819 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23820 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23821 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23822 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23823 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23824 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23825 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23826 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23827 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23828 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23829 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23830 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23831 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23832 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23833 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23834 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23835 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23836 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23837 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23838 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23839 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23840 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23841 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23842 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23843 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       161
23844 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         negi
23845 
23846 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME negi
23847 
23848   /* The residual arity for this instruction does not depend on fast labels. */
23849   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23850 
23851 
23852 #if defined (JITTER_PROFILE_SAMPLE)
23853   JITTER_PROFILE_SAMPLE_UPDATE
23854      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23855       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23856   /* Force the compiler not move sample-profiling instrumentation
23857      beyond this point; this way the actual user code is timed.
23858      This is still not perfect, as residuals are materialised before
23859      we arrive here, but should be adequate at least for slow VM
23860      instructions. */
23861   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23862 #endif
23863 #if defined (JITTER_PROFILE_COUNT)
23864   /* Notice that, differently from the code above, this
23865      instrumentation code *can* be reordered freely: as long as a
23866      VM instruction is counted, the count increment can be placed
23867      anyehere.  Let GCC move this code and possibly achieve better
23868      throughput by exploiting instruction-level parallelism and
23869      therefore approximate more closely a non-profiled build. */
23870   JITTER_PROFILE_COUNT_UPDATE
23871      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23872       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23873 #endif
23874 
23875 /* User-specified code, instruction-beginning-c part: beginning. */
23876 
23877 /* User-specified code, instruction-beginning-c part: end */
23878 
23879 
23880     /* User code for negi . */
23881 #line 2570 "../../libpoke/pvm.jitter"
23882 
23883     PVM_NEG_SIGNED (INT, int);
23884 
23885     /* End of the user code for negi . */
23886 
23887 /* User-specified code, instruction-end-c part: beginning. */
23888 
23889 /* User-specified code, instruction-end-c part: end */
23890 
23891     /* Undefine the negi argument macros so they can't be used
23892        by mistake in the instruction body coming next. */
23893 
23894 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23895 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23896 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23897 
23898   }
23899  JITTER_INSTRUCTION_EPILOG_(negi, negi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23900 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23901 
23902   JITTER_INSTRUCTION_PROLOG_(negiu, negiu, hot)
23903   {
23904     /* This specialized instruction is not a replacement. */
23905 #   undef JITTER_BRANCH_FAST
23906 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23907 #   undef JITTER_BRANCH_FAST_IF_ZERO
23908 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23909 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23910 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23911 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23912 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23913 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23914 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23915 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23916 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23917 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23918 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23919 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23920 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23921 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23922 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23923 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23924 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23925 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23926 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23927 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23928 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23929 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23930 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23931 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23932 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23933 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23934 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23935 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23936 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23937 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23938 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23939 #   undef JITTER_BRANCH_FAST_IF_AND
23940 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23941 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23942 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23943 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23944 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23945 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23946 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23947 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23948 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23949 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23950 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23951 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23952 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23953 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23954 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23955 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23956 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23957 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23958 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23959 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23960 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23961 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23962 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23963 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23964 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23965 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23966 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23967 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23968 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23969 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       162
23970 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         negiu
23971 
23972 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME negiu
23973 
23974   /* The residual arity for this instruction does not depend on fast labels. */
23975   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
23976 
23977 
23978 #if defined (JITTER_PROFILE_SAMPLE)
23979   JITTER_PROFILE_SAMPLE_UPDATE
23980      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23981       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23982   /* Force the compiler not move sample-profiling instrumentation
23983      beyond this point; this way the actual user code is timed.
23984      This is still not perfect, as residuals are materialised before
23985      we arrive here, but should be adequate at least for slow VM
23986      instructions. */
23987   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23988 #endif
23989 #if defined (JITTER_PROFILE_COUNT)
23990   /* Notice that, differently from the code above, this
23991      instrumentation code *can* be reordered freely: as long as a
23992      VM instruction is counted, the count increment can be placed
23993      anyehere.  Let GCC move this code and possibly achieve better
23994      throughput by exploiting instruction-level parallelism and
23995      therefore approximate more closely a non-profiled build. */
23996   JITTER_PROFILE_COUNT_UPDATE
23997      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23998       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23999 #endif
24000 
24001 /* User-specified code, instruction-beginning-c part: beginning. */
24002 
24003 /* User-specified code, instruction-beginning-c part: end */
24004 
24005 
24006     /* User code for negiu . */
24007 #line 2583 "../../libpoke/pvm.jitter"
24008 
24009     PVM_UNOP (UINT, UINT, uint, -);
24010 
24011     /* End of the user code for negiu . */
24012 
24013 /* User-specified code, instruction-end-c part: beginning. */
24014 
24015 /* User-specified code, instruction-end-c part: end */
24016 
24017     /* Undefine the negiu argument macros so they can't be used
24018        by mistake in the instruction body coming next. */
24019 
24020 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24021 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24022 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24023 
24024   }
24025  JITTER_INSTRUCTION_EPILOG_(negiu, negiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24026 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24027 
24028   JITTER_INSTRUCTION_PROLOG_(negl, negl, hot)
24029   {
24030     /* This specialized instruction is not a replacement. */
24031 #   undef JITTER_BRANCH_FAST
24032 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24033 #   undef JITTER_BRANCH_FAST_IF_ZERO
24034 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24035 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24036 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24037 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24038 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24039 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24040 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24041 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24042 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24043 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24044 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24045 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24046 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24047 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24048 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24049 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24050 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24051 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24052 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24053 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24054 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24055 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24056 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24057 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24058 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24059 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24060 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24061 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24062 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24063 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24064 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24065 #   undef JITTER_BRANCH_FAST_IF_AND
24066 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24067 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24068 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24069 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24070 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24071 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24072 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24073 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24074 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24075 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24076 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24077 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24078 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24079 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24080 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24081 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24082 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24083 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24084 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24085 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24086 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24087 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24088 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24089 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24090 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24091 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24092 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24093 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24094 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24095 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       163
24096 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         negl
24097 
24098 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME negl
24099 
24100   /* The residual arity for this instruction does not depend on fast labels. */
24101   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24102 
24103 
24104 #if defined (JITTER_PROFILE_SAMPLE)
24105   JITTER_PROFILE_SAMPLE_UPDATE
24106      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24107       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24108   /* Force the compiler not move sample-profiling instrumentation
24109      beyond this point; this way the actual user code is timed.
24110      This is still not perfect, as residuals are materialised before
24111      we arrive here, but should be adequate at least for slow VM
24112      instructions. */
24113   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24114 #endif
24115 #if defined (JITTER_PROFILE_COUNT)
24116   /* Notice that, differently from the code above, this
24117      instrumentation code *can* be reordered freely: as long as a
24118      VM instruction is counted, the count increment can be placed
24119      anyehere.  Let GCC move this code and possibly achieve better
24120      throughput by exploiting instruction-level parallelism and
24121      therefore approximate more closely a non-profiled build. */
24122   JITTER_PROFILE_COUNT_UPDATE
24123      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24124       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24125 #endif
24126 
24127 /* User-specified code, instruction-beginning-c part: beginning. */
24128 
24129 /* User-specified code, instruction-beginning-c part: end */
24130 
24131 
24132     /* User code for negl . */
24133 #line 2596 "../../libpoke/pvm.jitter"
24134 
24135     PVM_NEG_SIGNED (LONG, int64_t);
24136 
24137     /* End of the user code for negl . */
24138 
24139 /* User-specified code, instruction-end-c part: beginning. */
24140 
24141 /* User-specified code, instruction-end-c part: end */
24142 
24143     /* Undefine the negl argument macros so they can't be used
24144        by mistake in the instruction body coming next. */
24145 
24146 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24147 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24148 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24149 
24150   }
24151  JITTER_INSTRUCTION_EPILOG_(negl, negl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24152 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24153 
24154   JITTER_INSTRUCTION_PROLOG_(neglu, neglu, hot)
24155   {
24156     /* This specialized instruction is not a replacement. */
24157 #   undef JITTER_BRANCH_FAST
24158 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24159 #   undef JITTER_BRANCH_FAST_IF_ZERO
24160 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24161 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24162 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24163 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24164 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24165 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24166 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24167 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24168 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24169 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24170 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24171 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24172 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24173 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24174 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24175 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24176 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24177 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24178 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24179 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24180 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24181 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24182 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24183 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24184 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24185 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24186 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24187 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24188 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24189 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24190 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24191 #   undef JITTER_BRANCH_FAST_IF_AND
24192 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24193 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24194 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24195 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24196 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24197 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24198 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24199 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24200 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24201 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24202 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24203 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24204 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24205 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24206 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24207 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24208 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24209 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24210 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24211 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24212 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24213 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24214 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24215 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24216 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24217 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24218 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24219 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24220 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24221 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       164
24222 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         neglu
24223 
24224 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME neglu
24225 
24226   /* The residual arity for this instruction does not depend on fast labels. */
24227   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24228 
24229 
24230 #if defined (JITTER_PROFILE_SAMPLE)
24231   JITTER_PROFILE_SAMPLE_UPDATE
24232      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24233       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24234   /* Force the compiler not move sample-profiling instrumentation
24235      beyond this point; this way the actual user code is timed.
24236      This is still not perfect, as residuals are materialised before
24237      we arrive here, but should be adequate at least for slow VM
24238      instructions. */
24239   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24240 #endif
24241 #if defined (JITTER_PROFILE_COUNT)
24242   /* Notice that, differently from the code above, this
24243      instrumentation code *can* be reordered freely: as long as a
24244      VM instruction is counted, the count increment can be placed
24245      anyehere.  Let GCC move this code and possibly achieve better
24246      throughput by exploiting instruction-level parallelism and
24247      therefore approximate more closely a non-profiled build. */
24248   JITTER_PROFILE_COUNT_UPDATE
24249      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24250       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24251 #endif
24252 
24253 /* User-specified code, instruction-beginning-c part: beginning. */
24254 
24255 /* User-specified code, instruction-beginning-c part: end */
24256 
24257 
24258     /* User code for neglu . */
24259 #line 2609 "../../libpoke/pvm.jitter"
24260 
24261     PVM_UNOP (ULONG, ULONG, ulong, -);
24262 
24263     /* End of the user code for neglu . */
24264 
24265 /* User-specified code, instruction-end-c part: beginning. */
24266 
24267 /* User-specified code, instruction-end-c part: end */
24268 
24269     /* Undefine the neglu argument macros so they can't be used
24270        by mistake in the instruction body coming next. */
24271 
24272 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24273 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24274 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24275 
24276   }
24277  JITTER_INSTRUCTION_EPILOG_(neglu, neglu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24278 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24279 
24280   JITTER_INSTRUCTION_PROLOG_(nei, nei, hot)
24281   {
24282     /* This specialized instruction is not a replacement. */
24283 #   undef JITTER_BRANCH_FAST
24284 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24285 #   undef JITTER_BRANCH_FAST_IF_ZERO
24286 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24287 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24288 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24289 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24290 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24291 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24292 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24293 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24294 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24295 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24296 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24297 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24298 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24299 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24300 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24301 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24302 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24303 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24304 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24305 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24306 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24307 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24308 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24309 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24310 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24311 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24312 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24313 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24314 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24315 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24316 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24317 #   undef JITTER_BRANCH_FAST_IF_AND
24318 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24319 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24320 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24321 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24322 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24323 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24324 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24325 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24326 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24327 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24328 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24329 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24330 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24331 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24332 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24333 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24334 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24335 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24336 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24337 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24338 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24339 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24340 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24341 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24342 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24343 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24344 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24345 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24346 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24347 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       165
24348 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nei
24349 
24350 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nei
24351 
24352   /* The residual arity for this instruction does not depend on fast labels. */
24353   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24354 
24355 
24356 #if defined (JITTER_PROFILE_SAMPLE)
24357   JITTER_PROFILE_SAMPLE_UPDATE
24358      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24359       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24360   /* Force the compiler not move sample-profiling instrumentation
24361      beyond this point; this way the actual user code is timed.
24362      This is still not perfect, as residuals are materialised before
24363      we arrive here, but should be adequate at least for slow VM
24364      instructions. */
24365   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24366 #endif
24367 #if defined (JITTER_PROFILE_COUNT)
24368   /* Notice that, differently from the code above, this
24369      instrumentation code *can* be reordered freely: as long as a
24370      VM instruction is counted, the count increment can be placed
24371      anyehere.  Let GCC move this code and possibly achieve better
24372      throughput by exploiting instruction-level parallelism and
24373      therefore approximate more closely a non-profiled build. */
24374   JITTER_PROFILE_COUNT_UPDATE
24375      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24376       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24377 #endif
24378 
24379 /* User-specified code, instruction-beginning-c part: beginning. */
24380 
24381 /* User-specified code, instruction-beginning-c part: end */
24382 
24383 
24384     /* User code for nei . */
24385 #line 2749 "../../libpoke/pvm.jitter"
24386 
24387      PVM_BOOL_BINOP (INT, !=);
24388 
24389     /* End of the user code for nei . */
24390 
24391 /* User-specified code, instruction-end-c part: beginning. */
24392 
24393 /* User-specified code, instruction-end-c part: end */
24394 
24395     /* Undefine the nei argument macros so they can't be used
24396        by mistake in the instruction body coming next. */
24397 
24398 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24399 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24400 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24401 
24402   }
24403  JITTER_INSTRUCTION_EPILOG_(nei, nei, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24404 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24405 
24406   JITTER_INSTRUCTION_PROLOG_(neiu, neiu, hot)
24407   {
24408     /* This specialized instruction is not a replacement. */
24409 #   undef JITTER_BRANCH_FAST
24410 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24411 #   undef JITTER_BRANCH_FAST_IF_ZERO
24412 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24413 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24414 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24415 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24416 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24417 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24418 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24419 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24420 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24421 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24422 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24423 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24424 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24425 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24426 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24427 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24428 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24429 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24430 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24431 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24432 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24433 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24434 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24435 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24436 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24437 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24438 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24439 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24440 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24441 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24442 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24443 #   undef JITTER_BRANCH_FAST_IF_AND
24444 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24445 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24446 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24447 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24448 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24449 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24450 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24451 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24452 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24453 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24454 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24455 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24456 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24457 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24458 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24459 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24460 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24461 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24462 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24463 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24464 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24465 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24466 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24467 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24468 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24469 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24470 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24471 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24472 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24473 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       166
24474 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         neiu
24475 
24476 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME neiu
24477 
24478   /* The residual arity for this instruction does not depend on fast labels. */
24479   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24480 
24481 
24482 #if defined (JITTER_PROFILE_SAMPLE)
24483   JITTER_PROFILE_SAMPLE_UPDATE
24484      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24485       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24486   /* Force the compiler not move sample-profiling instrumentation
24487      beyond this point; this way the actual user code is timed.
24488      This is still not perfect, as residuals are materialised before
24489      we arrive here, but should be adequate at least for slow VM
24490      instructions. */
24491   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24492 #endif
24493 #if defined (JITTER_PROFILE_COUNT)
24494   /* Notice that, differently from the code above, this
24495      instrumentation code *can* be reordered freely: as long as a
24496      VM instruction is counted, the count increment can be placed
24497      anyehere.  Let GCC move this code and possibly achieve better
24498      throughput by exploiting instruction-level parallelism and
24499      therefore approximate more closely a non-profiled build. */
24500   JITTER_PROFILE_COUNT_UPDATE
24501      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24502       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24503 #endif
24504 
24505 /* User-specified code, instruction-beginning-c part: beginning. */
24506 
24507 /* User-specified code, instruction-beginning-c part: end */
24508 
24509 
24510     /* User code for neiu . */
24511 #line 2762 "../../libpoke/pvm.jitter"
24512 
24513      PVM_BOOL_BINOP (UINT, !=);
24514 
24515     /* End of the user code for neiu . */
24516 
24517 /* User-specified code, instruction-end-c part: beginning. */
24518 
24519 /* User-specified code, instruction-end-c part: end */
24520 
24521     /* Undefine the neiu argument macros so they can't be used
24522        by mistake in the instruction body coming next. */
24523 
24524 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24525 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24526 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24527 
24528   }
24529  JITTER_INSTRUCTION_EPILOG_(neiu, neiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24530 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24531 
24532   JITTER_INSTRUCTION_PROLOG_(nel, nel, hot)
24533   {
24534     /* This specialized instruction is not a replacement. */
24535 #   undef JITTER_BRANCH_FAST
24536 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24537 #   undef JITTER_BRANCH_FAST_IF_ZERO
24538 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24539 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24540 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24541 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24542 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24543 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24544 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24545 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24546 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24547 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24548 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24549 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24550 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24551 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24552 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24553 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24554 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24555 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24556 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24557 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24558 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24559 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24560 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24561 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24562 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24563 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24564 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24565 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24566 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24567 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24568 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24569 #   undef JITTER_BRANCH_FAST_IF_AND
24570 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24571 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24572 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24573 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24574 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24575 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24576 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24577 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24578 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24579 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24580 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24581 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24582 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24583 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24584 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24585 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24586 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24587 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24588 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24589 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24590 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24591 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24592 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24593 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24594 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24595 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24596 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24597 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24598 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24599 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       167
24600 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nel
24601 
24602 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nel
24603 
24604   /* The residual arity for this instruction does not depend on fast labels. */
24605   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24606 
24607 
24608 #if defined (JITTER_PROFILE_SAMPLE)
24609   JITTER_PROFILE_SAMPLE_UPDATE
24610      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24611       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24612   /* Force the compiler not move sample-profiling instrumentation
24613      beyond this point; this way the actual user code is timed.
24614      This is still not perfect, as residuals are materialised before
24615      we arrive here, but should be adequate at least for slow VM
24616      instructions. */
24617   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24618 #endif
24619 #if defined (JITTER_PROFILE_COUNT)
24620   /* Notice that, differently from the code above, this
24621      instrumentation code *can* be reordered freely: as long as a
24622      VM instruction is counted, the count increment can be placed
24623      anyehere.  Let GCC move this code and possibly achieve better
24624      throughput by exploiting instruction-level parallelism and
24625      therefore approximate more closely a non-profiled build. */
24626   JITTER_PROFILE_COUNT_UPDATE
24627      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24628       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24629 #endif
24630 
24631 /* User-specified code, instruction-beginning-c part: beginning. */
24632 
24633 /* User-specified code, instruction-beginning-c part: end */
24634 
24635 
24636     /* User code for nel . */
24637 #line 2775 "../../libpoke/pvm.jitter"
24638 
24639      PVM_BOOL_BINOP (LONG, !=);
24640 
24641     /* End of the user code for nel . */
24642 
24643 /* User-specified code, instruction-end-c part: beginning. */
24644 
24645 /* User-specified code, instruction-end-c part: end */
24646 
24647     /* Undefine the nel argument macros so they can't be used
24648        by mistake in the instruction body coming next. */
24649 
24650 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24651 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24652 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24653 
24654   }
24655  JITTER_INSTRUCTION_EPILOG_(nel, nel, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24656 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24657 
24658   JITTER_INSTRUCTION_PROLOG_(nelu, nelu, hot)
24659   {
24660     /* This specialized instruction is not a replacement. */
24661 #   undef JITTER_BRANCH_FAST
24662 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24663 #   undef JITTER_BRANCH_FAST_IF_ZERO
24664 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24665 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24666 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24667 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24668 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24669 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24670 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24671 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24672 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24673 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24674 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24675 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24676 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24677 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24678 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24679 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24680 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24681 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24682 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24683 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24684 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24685 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24686 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24687 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24688 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24689 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24690 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24691 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24692 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24693 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24694 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24695 #   undef JITTER_BRANCH_FAST_IF_AND
24696 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24697 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24698 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24699 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24700 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24701 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24702 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24703 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24704 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24705 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24706 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24707 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24708 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24709 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24710 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24711 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24712 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24713 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24714 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24715 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24716 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24717 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24718 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24719 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24720 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24721 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24722 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24723 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24724 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24725 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       168
24726 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nelu
24727 
24728 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nelu
24729 
24730   /* The residual arity for this instruction does not depend on fast labels. */
24731   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24732 
24733 
24734 #if defined (JITTER_PROFILE_SAMPLE)
24735   JITTER_PROFILE_SAMPLE_UPDATE
24736      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24737       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24738   /* Force the compiler not move sample-profiling instrumentation
24739      beyond this point; this way the actual user code is timed.
24740      This is still not perfect, as residuals are materialised before
24741      we arrive here, but should be adequate at least for slow VM
24742      instructions. */
24743   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24744 #endif
24745 #if defined (JITTER_PROFILE_COUNT)
24746   /* Notice that, differently from the code above, this
24747      instrumentation code *can* be reordered freely: as long as a
24748      VM instruction is counted, the count increment can be placed
24749      anyehere.  Let GCC move this code and possibly achieve better
24750      throughput by exploiting instruction-level parallelism and
24751      therefore approximate more closely a non-profiled build. */
24752   JITTER_PROFILE_COUNT_UPDATE
24753      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24754       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24755 #endif
24756 
24757 /* User-specified code, instruction-beginning-c part: beginning. */
24758 
24759 /* User-specified code, instruction-beginning-c part: end */
24760 
24761 
24762     /* User code for nelu . */
24763 #line 2788 "../../libpoke/pvm.jitter"
24764 
24765      PVM_BOOL_BINOP (ULONG, !=);
24766 
24767     /* End of the user code for nelu . */
24768 
24769 /* User-specified code, instruction-end-c part: beginning. */
24770 
24771 /* User-specified code, instruction-end-c part: end */
24772 
24773     /* Undefine the nelu argument macros so they can't be used
24774        by mistake in the instruction body coming next. */
24775 
24776 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24777 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24778 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24779 
24780   }
24781  JITTER_INSTRUCTION_EPILOG_(nelu, nelu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24782 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24783 
24784   JITTER_INSTRUCTION_PROLOG_(nes, nes, hot)
24785   {
24786     /* This specialized instruction is not a replacement. */
24787 #   undef JITTER_BRANCH_FAST
24788 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24789 #   undef JITTER_BRANCH_FAST_IF_ZERO
24790 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24791 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24792 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24793 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24794 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24795 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24796 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24797 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24798 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24799 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24800 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24801 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24802 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24803 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24804 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24805 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24806 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24807 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24808 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24809 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24810 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24811 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24812 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24813 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24814 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24815 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24816 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24817 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24818 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24819 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24820 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24821 #   undef JITTER_BRANCH_FAST_IF_AND
24822 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24823 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24824 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24825 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24826 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24827 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24828 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24829 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24830 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24831 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24832 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24833 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24834 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24835 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24836 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24837 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24838 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24839 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24840 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24841 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24842 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24843 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24844 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24845 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24846 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24847 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24848 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24849 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24850 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24851 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       169
24852 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nes
24853 
24854 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nes
24855 
24856   /* The residual arity for this instruction does not depend on fast labels. */
24857   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24858 
24859 
24860 #if defined (JITTER_PROFILE_SAMPLE)
24861   JITTER_PROFILE_SAMPLE_UPDATE
24862      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24863       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24864   /* Force the compiler not move sample-profiling instrumentation
24865      beyond this point; this way the actual user code is timed.
24866      This is still not perfect, as residuals are materialised before
24867      we arrive here, but should be adequate at least for slow VM
24868      instructions. */
24869   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24870 #endif
24871 #if defined (JITTER_PROFILE_COUNT)
24872   /* Notice that, differently from the code above, this
24873      instrumentation code *can* be reordered freely: as long as a
24874      VM instruction is counted, the count increment can be placed
24875      anyehere.  Let GCC move this code and possibly achieve better
24876      throughput by exploiting instruction-level parallelism and
24877      therefore approximate more closely a non-profiled build. */
24878   JITTER_PROFILE_COUNT_UPDATE
24879      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24880       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24881 #endif
24882 
24883 /* User-specified code, instruction-beginning-c part: beginning. */
24884 
24885 /* User-specified code, instruction-beginning-c part: end */
24886 
24887 
24888     /* User code for nes . */
24889 #line 2801 "../../libpoke/pvm.jitter"
24890 
24891     pvm_val res = PVM_MAKE_INT (STRNEQ (PVM_VAL_STR (JITTER_UNDER_TOP_STACK ()),
24892                                         PVM_VAL_STR (JITTER_TOP_STACK ())),
24893                                 32);
24894     JITTER_PUSH_STACK (res);
24895 
24896     /* End of the user code for nes . */
24897 
24898 /* User-specified code, instruction-end-c part: beginning. */
24899 
24900 /* User-specified code, instruction-end-c part: end */
24901 
24902     /* Undefine the nes argument macros so they can't be used
24903        by mistake in the instruction body coming next. */
24904 
24905 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24906 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24907 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24908 
24909   }
24910  JITTER_INSTRUCTION_EPILOG_(nes, nes, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24911 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24912 
24913   JITTER_INSTRUCTION_PROLOG_(nip, nip, hot)
24914   {
24915     /* This specialized instruction is not a replacement. */
24916 #   undef JITTER_BRANCH_FAST
24917 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24918 #   undef JITTER_BRANCH_FAST_IF_ZERO
24919 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24920 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24921 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24922 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24923 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24924 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24925 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24926 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24927 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24928 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24929 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24930 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24931 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24932 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24933 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24934 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24935 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24936 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24937 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24938 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24939 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24940 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24941 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24942 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24943 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24944 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24945 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24946 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24947 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24948 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24949 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24950 #   undef JITTER_BRANCH_FAST_IF_AND
24951 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24952 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24953 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24954 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24955 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24956 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24957 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24958 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24959 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24960 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24961 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24962 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24963 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24964 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24965 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24966 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24967 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24968 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24969 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24970 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24971 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24972 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24973 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24974 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24975 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24976 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24977 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24978 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24979 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24980 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       170
24981 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip
24982 
24983 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip
24984 
24985   /* The residual arity for this instruction does not depend on fast labels. */
24986   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24987 
24988 
24989 #if defined (JITTER_PROFILE_SAMPLE)
24990   JITTER_PROFILE_SAMPLE_UPDATE
24991      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24992       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24993   /* Force the compiler not move sample-profiling instrumentation
24994      beyond this point; this way the actual user code is timed.
24995      This is still not perfect, as residuals are materialised before
24996      we arrive here, but should be adequate at least for slow VM
24997      instructions. */
24998   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24999 #endif
25000 #if defined (JITTER_PROFILE_COUNT)
25001   /* Notice that, differently from the code above, this
25002      instrumentation code *can* be reordered freely: as long as a
25003      VM instruction is counted, the count increment can be placed
25004      anyehere.  Let GCC move this code and possibly achieve better
25005      throughput by exploiting instruction-level parallelism and
25006      therefore approximate more closely a non-profiled build. */
25007   JITTER_PROFILE_COUNT_UPDATE
25008      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25009       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25010 #endif
25011 
25012 /* User-specified code, instruction-beginning-c part: beginning. */
25013 
25014 /* User-specified code, instruction-beginning-c part: end */
25015 
25016 
25017     /* User code for nip . */
25018 #line 1999 "../../libpoke/pvm.jitter"
25019 
25020     JITTER_NIP_STACK();
25021 
25022     /* End of the user code for nip . */
25023 
25024 /* User-specified code, instruction-end-c part: beginning. */
25025 
25026 /* User-specified code, instruction-end-c part: end */
25027 
25028     /* Undefine the nip argument macros so they can't be used
25029        by mistake in the instruction body coming next. */
25030 
25031 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25032 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25033 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25034 
25035   }
25036  JITTER_INSTRUCTION_EPILOG_(nip, nip, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25037 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25038 
25039   JITTER_INSTRUCTION_PROLOG_(nip2, nip2, hot)
25040   {
25041     /* This specialized instruction is not a replacement. */
25042 #   undef JITTER_BRANCH_FAST
25043 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25044 #   undef JITTER_BRANCH_FAST_IF_ZERO
25045 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25046 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25047 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25048 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25049 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25050 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25051 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25052 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25053 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25054 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25055 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25056 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25057 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25058 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25059 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25060 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25061 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25062 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25063 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25064 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25065 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25066 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25067 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25068 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25069 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25070 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25071 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25072 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25073 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25074 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25075 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25076 #   undef JITTER_BRANCH_FAST_IF_AND
25077 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25078 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25079 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25080 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25081 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25082 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25083 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25084 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25085 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25086 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25087 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25088 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25089 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25090 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25091 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25092 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25093 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25094 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25095 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25096 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25097 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25098 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25099 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25100 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25101 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25102 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25103 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25104 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25105 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25106 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       171
25107 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip2
25108 
25109 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip2
25110 
25111   /* The residual arity for this instruction does not depend on fast labels. */
25112   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25113 
25114 
25115 #if defined (JITTER_PROFILE_SAMPLE)
25116   JITTER_PROFILE_SAMPLE_UPDATE
25117      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25118       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25119   /* Force the compiler not move sample-profiling instrumentation
25120      beyond this point; this way the actual user code is timed.
25121      This is still not perfect, as residuals are materialised before
25122      we arrive here, but should be adequate at least for slow VM
25123      instructions. */
25124   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25125 #endif
25126 #if defined (JITTER_PROFILE_COUNT)
25127   /* Notice that, differently from the code above, this
25128      instrumentation code *can* be reordered freely: as long as a
25129      VM instruction is counted, the count increment can be placed
25130      anyehere.  Let GCC move this code and possibly achieve better
25131      throughput by exploiting instruction-level parallelism and
25132      therefore approximate more closely a non-profiled build. */
25133   JITTER_PROFILE_COUNT_UPDATE
25134      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25135       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25136 #endif
25137 
25138 /* User-specified code, instruction-beginning-c part: beginning. */
25139 
25140 /* User-specified code, instruction-beginning-c part: end */
25141 
25142 
25143     /* User code for nip2 . */
25144 #line 2011 "../../libpoke/pvm.jitter"
25145 
25146     JITTER_NIP_STACK ();
25147     JITTER_NIP_STACK ();
25148 
25149     /* End of the user code for nip2 . */
25150 
25151 /* User-specified code, instruction-end-c part: beginning. */
25152 
25153 /* User-specified code, instruction-end-c part: end */
25154 
25155     /* Undefine the nip2 argument macros so they can't be used
25156        by mistake in the instruction body coming next. */
25157 
25158 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25159 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25160 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25161 
25162   }
25163  JITTER_INSTRUCTION_EPILOG_(nip2, nip2, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25164 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25165 
25166   JITTER_INSTRUCTION_PROLOG_(nip3, nip3, hot)
25167   {
25168     /* This specialized instruction is not a replacement. */
25169 #   undef JITTER_BRANCH_FAST
25170 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25171 #   undef JITTER_BRANCH_FAST_IF_ZERO
25172 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25173 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25174 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25175 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25176 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25177 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25178 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25179 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25180 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25181 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25182 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25183 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25184 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25185 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25186 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25187 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25188 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25189 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25190 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25191 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25192 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25193 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25194 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25195 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25196 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25197 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25198 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25199 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25200 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25201 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25202 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25203 #   undef JITTER_BRANCH_FAST_IF_AND
25204 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25205 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25206 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25207 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25208 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25209 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25210 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25211 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25212 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25213 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25214 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25215 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25216 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25217 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25218 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25219 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25220 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25221 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25222 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25223 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25224 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25225 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25226 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25227 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25228 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25229 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25230 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25231 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25232 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25233 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       172
25234 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip3
25235 
25236 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip3
25237 
25238   /* The residual arity for this instruction does not depend on fast labels. */
25239   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25240 
25241 
25242 #if defined (JITTER_PROFILE_SAMPLE)
25243   JITTER_PROFILE_SAMPLE_UPDATE
25244      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25245       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25246   /* Force the compiler not move sample-profiling instrumentation
25247      beyond this point; this way the actual user code is timed.
25248      This is still not perfect, as residuals are materialised before
25249      we arrive here, but should be adequate at least for slow VM
25250      instructions. */
25251   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25252 #endif
25253 #if defined (JITTER_PROFILE_COUNT)
25254   /* Notice that, differently from the code above, this
25255      instrumentation code *can* be reordered freely: as long as a
25256      VM instruction is counted, the count increment can be placed
25257      anyehere.  Let GCC move this code and possibly achieve better
25258      throughput by exploiting instruction-level parallelism and
25259      therefore approximate more closely a non-profiled build. */
25260   JITTER_PROFILE_COUNT_UPDATE
25261      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25262       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25263 #endif
25264 
25265 /* User-specified code, instruction-beginning-c part: beginning. */
25266 
25267 /* User-specified code, instruction-beginning-c part: end */
25268 
25269 
25270     /* User code for nip3 . */
25271 #line 2024 "../../libpoke/pvm.jitter"
25272 
25273     JITTER_NIP_STACK ();
25274     JITTER_NIP_STACK ();
25275     JITTER_NIP_STACK ();
25276 
25277     /* End of the user code for nip3 . */
25278 
25279 /* User-specified code, instruction-end-c part: beginning. */
25280 
25281 /* User-specified code, instruction-end-c part: end */
25282 
25283     /* Undefine the nip3 argument macros so they can't be used
25284        by mistake in the instruction body coming next. */
25285 
25286 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25287 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25288 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25289 
25290   }
25291  JITTER_INSTRUCTION_EPILOG_(nip3, nip3, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25292 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25293 
25294   JITTER_INSTRUCTION_PROLOG_(nn, nn, hot)
25295   {
25296     /* This specialized instruction is not a replacement. */
25297 #   undef JITTER_BRANCH_FAST
25298 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25299 #   undef JITTER_BRANCH_FAST_IF_ZERO
25300 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25301 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25302 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25303 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25304 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25305 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25306 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25307 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25308 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25309 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25310 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25311 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25312 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25313 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25314 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25315 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25316 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25317 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25318 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25319 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25320 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25321 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25322 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25323 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25324 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25325 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25326 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25327 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25328 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25329 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25330 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25331 #   undef JITTER_BRANCH_FAST_IF_AND
25332 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25333 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25334 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25335 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25336 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25337 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25338 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25339 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25340 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25341 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25342 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25343 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25344 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25345 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25346 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25347 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25348 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25349 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25350 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25351 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25352 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25353 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25354 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25355 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25356 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25357 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25358 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25359 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25360 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25361 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       173
25362 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nn
25363 
25364 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nn
25365 
25366   /* The residual arity for this instruction does not depend on fast labels. */
25367   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25368 
25369 
25370 #if defined (JITTER_PROFILE_SAMPLE)
25371   JITTER_PROFILE_SAMPLE_UPDATE
25372      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25373       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25374   /* Force the compiler not move sample-profiling instrumentation
25375      beyond this point; this way the actual user code is timed.
25376      This is still not perfect, as residuals are materialised before
25377      we arrive here, but should be adequate at least for slow VM
25378      instructions. */
25379   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25380 #endif
25381 #if defined (JITTER_PROFILE_COUNT)
25382   /* Notice that, differently from the code above, this
25383      instrumentation code *can* be reordered freely: as long as a
25384      VM instruction is counted, the count increment can be placed
25385      anyehere.  Let GCC move this code and possibly achieve better
25386      throughput by exploiting instruction-level parallelism and
25387      therefore approximate more closely a non-profiled build. */
25388   JITTER_PROFILE_COUNT_UPDATE
25389      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25390       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25391 #endif
25392 
25393 /* User-specified code, instruction-beginning-c part: beginning. */
25394 
25395 /* User-specified code, instruction-beginning-c part: end */
25396 
25397 
25398     /* User code for nn . */
25399 #line 2817 "../../libpoke/pvm.jitter"
25400 
25401      JITTER_PUSH_STACK (PVM_MAKE_INT (JITTER_TOP_STACK () != PVM_NULL,
25402                                       32));
25403 
25404     /* End of the user code for nn . */
25405 
25406 /* User-specified code, instruction-end-c part: beginning. */
25407 
25408 /* User-specified code, instruction-end-c part: end */
25409 
25410     /* Undefine the nn argument macros so they can't be used
25411        by mistake in the instruction body coming next. */
25412 
25413 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25414 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25415 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25416 
25417   }
25418  JITTER_INSTRUCTION_EPILOG_(nn, nn, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25419 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25420 
25421   JITTER_INSTRUCTION_PROLOG_(nnn, nnn, hot)
25422   {
25423     /* This specialized instruction is not a replacement. */
25424 #   undef JITTER_BRANCH_FAST
25425 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25426 #   undef JITTER_BRANCH_FAST_IF_ZERO
25427 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25428 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25429 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25430 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25431 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25432 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25433 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25434 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25435 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25436 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25437 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25438 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25439 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25440 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25441 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25442 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25443 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25444 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25445 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25446 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25447 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25448 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25449 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25450 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25451 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25452 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25453 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25454 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25455 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25456 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25457 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25458 #   undef JITTER_BRANCH_FAST_IF_AND
25459 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25460 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25461 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25462 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25463 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25464 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25465 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25466 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25467 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25468 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25469 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25470 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25471 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25472 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25473 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25474 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25475 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25476 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25477 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25478 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25479 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25480 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25481 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25482 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25483 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25484 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25485 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25486 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25487 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25488 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       174
25489 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nnn
25490 
25491 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nnn
25492 
25493   /* The residual arity for this instruction does not depend on fast labels. */
25494   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25495 
25496 
25497 #if defined (JITTER_PROFILE_SAMPLE)
25498   JITTER_PROFILE_SAMPLE_UPDATE
25499      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25500       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25501   /* Force the compiler not move sample-profiling instrumentation
25502      beyond this point; this way the actual user code is timed.
25503      This is still not perfect, as residuals are materialised before
25504      we arrive here, but should be adequate at least for slow VM
25505      instructions. */
25506   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25507 #endif
25508 #if defined (JITTER_PROFILE_COUNT)
25509   /* Notice that, differently from the code above, this
25510      instrumentation code *can* be reordered freely: as long as a
25511      VM instruction is counted, the count increment can be placed
25512      anyehere.  Let GCC move this code and possibly achieve better
25513      throughput by exploiting instruction-level parallelism and
25514      therefore approximate more closely a non-profiled build. */
25515   JITTER_PROFILE_COUNT_UPDATE
25516      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25517       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25518 #endif
25519 
25520 /* User-specified code, instruction-beginning-c part: beginning. */
25521 
25522 /* User-specified code, instruction-beginning-c part: end */
25523 
25524 
25525     /* User code for nnn . */
25526 #line 2831 "../../libpoke/pvm.jitter"
25527 
25528      JITTER_PUSH_STACK (PVM_MAKE_INT (JITTER_TOP_STACK () == PVM_NULL,
25529                                       32));
25530 
25531     /* End of the user code for nnn . */
25532 
25533 /* User-specified code, instruction-end-c part: beginning. */
25534 
25535 /* User-specified code, instruction-end-c part: end */
25536 
25537     /* Undefine the nnn argument macros so they can't be used
25538        by mistake in the instruction body coming next. */
25539 
25540 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25541 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25542 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25543 
25544   }
25545  JITTER_INSTRUCTION_EPILOG_(nnn, nnn, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25546 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25547 
25548   JITTER_INSTRUCTION_PROLOG_(nop, nop, hot)
25549   {
25550     /* This specialized instruction is not a replacement. */
25551 #   undef JITTER_BRANCH_FAST
25552 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25553 #   undef JITTER_BRANCH_FAST_IF_ZERO
25554 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25555 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25556 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25557 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25558 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25559 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25560 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25561 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25562 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25563 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25564 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25565 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25566 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25567 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25568 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25569 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25570 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25571 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25572 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25573 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25574 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25575 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25576 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25577 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25578 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25579 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25580 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25581 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25582 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25583 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25584 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25585 #   undef JITTER_BRANCH_FAST_IF_AND
25586 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25587 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25588 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25589 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25590 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25591 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25592 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25593 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25594 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25595 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25596 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25597 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25598 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25599 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25600 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25601 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25602 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25603 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25604 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25605 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25606 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25607 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25608 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25609 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25610 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25611 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25612 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25613 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25614 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25615 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       175
25616 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nop
25617 
25618 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nop
25619 
25620   /* The residual arity for this instruction does not depend on fast labels. */
25621   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25622 
25623 
25624 #if defined (JITTER_PROFILE_SAMPLE)
25625   JITTER_PROFILE_SAMPLE_UPDATE
25626      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25627       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25628   /* Force the compiler not move sample-profiling instrumentation
25629      beyond this point; this way the actual user code is timed.
25630      This is still not perfect, as residuals are materialised before
25631      we arrive here, but should be adequate at least for slow VM
25632      instructions. */
25633   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25634 #endif
25635 #if defined (JITTER_PROFILE_COUNT)
25636   /* Notice that, differently from the code above, this
25637      instrumentation code *can* be reordered freely: as long as a
25638      VM instruction is counted, the count increment can be placed
25639      anyehere.  Let GCC move this code and possibly achieve better
25640      throughput by exploiting instruction-level parallelism and
25641      therefore approximate more closely a non-profiled build. */
25642   JITTER_PROFILE_COUNT_UPDATE
25643      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25644       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25645 #endif
25646 
25647 /* User-specified code, instruction-beginning-c part: beginning. */
25648 
25649 /* User-specified code, instruction-beginning-c part: end */
25650 
25651 
25652     /* User code for nop . */
25653 #line 5707 "../../libpoke/pvm.jitter"
25654 
25655 
25656     /* End of the user code for nop . */
25657 
25658 /* User-specified code, instruction-end-c part: beginning. */
25659 
25660 /* User-specified code, instruction-end-c part: end */
25661 
25662     /* Undefine the nop argument macros so they can't be used
25663        by mistake in the instruction body coming next. */
25664 
25665 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25666 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25667 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25668 
25669   }
25670  JITTER_INSTRUCTION_EPILOG_(nop, nop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25671 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25672 
25673   JITTER_INSTRUCTION_PROLOG_(not, not, hot)
25674   {
25675     /* This specialized instruction is not a replacement. */
25676 #   undef JITTER_BRANCH_FAST
25677 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25678 #   undef JITTER_BRANCH_FAST_IF_ZERO
25679 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25680 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25681 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25682 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25683 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25684 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25685 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25686 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25687 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25688 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25689 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25690 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25691 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25692 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25693 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25694 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25695 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25696 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25697 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25698 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25699 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25700 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25701 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25702 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25703 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25704 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25705 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25706 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25707 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25708 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25709 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25710 #   undef JITTER_BRANCH_FAST_IF_AND
25711 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25712 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25713 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25714 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25715 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25716 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25717 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25718 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25719 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25720 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25721 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25722 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25723 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25724 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25725 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25726 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25727 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25728 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25729 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25730 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25731 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25732 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25733 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25734 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25735 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25736 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25737 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25738 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25739 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25740 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       176
25741 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         not
25742 
25743 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME not
25744 
25745   /* The residual arity for this instruction does not depend on fast labels. */
25746   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25747 
25748 
25749 #if defined (JITTER_PROFILE_SAMPLE)
25750   JITTER_PROFILE_SAMPLE_UPDATE
25751      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25752       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25753   /* Force the compiler not move sample-profiling instrumentation
25754      beyond this point; this way the actual user code is timed.
25755      This is still not perfect, as residuals are materialised before
25756      we arrive here, but should be adequate at least for slow VM
25757      instructions. */
25758   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25759 #endif
25760 #if defined (JITTER_PROFILE_COUNT)
25761   /* Notice that, differently from the code above, this
25762      instrumentation code *can* be reordered freely: as long as a
25763      VM instruction is counted, the count increment can be placed
25764      anyehere.  Let GCC move this code and possibly achieve better
25765      throughput by exploiting instruction-level parallelism and
25766      therefore approximate more closely a non-profiled build. */
25767   JITTER_PROFILE_COUNT_UPDATE
25768      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25769       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25770 #endif
25771 
25772 /* User-specified code, instruction-beginning-c part: beginning. */
25773 
25774 /* User-specified code, instruction-beginning-c part: end */
25775 
25776 
25777     /* User code for not . */
25778 #line 3166 "../../libpoke/pvm.jitter"
25779 
25780     pvm_val res = PVM_MAKE_INT (! PVM_VAL_INT (JITTER_TOP_STACK ()), 32);
25781     JITTER_PUSH_STACK (res);
25782 
25783     /* End of the user code for not . */
25784 
25785 /* User-specified code, instruction-end-c part: beginning. */
25786 
25787 /* User-specified code, instruction-end-c part: end */
25788 
25789     /* Undefine the not argument macros so they can't be used
25790        by mistake in the instruction body coming next. */
25791 
25792 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25793 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25794 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25795 
25796   }
25797  JITTER_INSTRUCTION_EPILOG_(not, not, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25798 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25799 
25800   JITTER_INSTRUCTION_PROLOG_(note/nR, note__nR, cold)
25801   {
25802     /* This specialized instruction is not a replacement. */
25803 #   undef JITTER_BRANCH_FAST
25804 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25805 #   undef JITTER_BRANCH_FAST_IF_ZERO
25806 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25807 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25808 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25809 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25810 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25811 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25812 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25813 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25814 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25815 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25816 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25817 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25818 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25819 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25820 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25821 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25822 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25823 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25824 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25825 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25826 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25827 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25828 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25829 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25830 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25831 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25832 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25833 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25834 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25835 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25836 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25837 #   undef JITTER_BRANCH_FAST_IF_AND
25838 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25839 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25840 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25841 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25842 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25843 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25844 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25845 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25846 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25847 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25848 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25849 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25850 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25851 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25852 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25853 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25854 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25855 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25856 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25857 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25858 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25859 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25860 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25861 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25862 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25863 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25864 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25865 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25866 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25867 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       177
25868 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         note/nR
25869 
25870 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME note__nR
25871 
25872   /* The residual arity for this instruction does not depend on fast labels. */
25873   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
25874 
25875     /* The 0th argument is a residual literal. */
25876 #if defined(JITTER_DISPATCH_NO_THREADING)
25877 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
25878     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
25879 #elif defined (JITTER_REPLICATE)
25880 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
25881 #else
25882 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
25883 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
25884 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
25885 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
25886 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
25887 #   define JITTER_ARGF0 JITTER_ARGP0
25888 
25889 
25890 #if defined (JITTER_PROFILE_SAMPLE)
25891   JITTER_PROFILE_SAMPLE_UPDATE
25892      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25893       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25894   /* Force the compiler not move sample-profiling instrumentation
25895      beyond this point; this way the actual user code is timed.
25896      This is still not perfect, as residuals are materialised before
25897      we arrive here, but should be adequate at least for slow VM
25898      instructions. */
25899   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25900 #endif
25901 #if defined (JITTER_PROFILE_COUNT)
25902   /* Notice that, differently from the code above, this
25903      instrumentation code *can* be reordered freely: as long as a
25904      VM instruction is counted, the count increment can be placed
25905      anyehere.  Let GCC move this code and possibly achieve better
25906      throughput by exploiting instruction-level parallelism and
25907      therefore approximate more closely a non-profiled build. */
25908   JITTER_PROFILE_COUNT_UPDATE
25909      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25910       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25911 #endif
25912 
25913 /* User-specified code, instruction-beginning-c part: beginning. */
25914 
25915 /* User-specified code, instruction-beginning-c part: end */
25916 
25917 
25918     /* User code for note/nR . */
25919 #line 5669 "../../libpoke/pvm.jitter"
25920 
25921 
25922     /* End of the user code for note/nR . */
25923 
25924 /* User-specified code, instruction-end-c part: beginning. */
25925 
25926 /* User-specified code, instruction-end-c part: end */
25927 
25928     /* Undefine the note/nR argument macros so they can't be used
25929        by mistake in the instruction body coming next. */
25930 #   undef JITTER_SLOW_REGISTER_OFFSET0
25931 #   undef JITTER_ARG0
25932 #   undef JITTER_ARGN0
25933 #   undef JITTER_ARGU0
25934 #   undef JITTER_ARGP0
25935 #   undef JITTER_ARGF0
25936 
25937 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25938 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25939 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25940 
25941   }
25942  JITTER_INSTRUCTION_EPILOG_(note/nR, note__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25943 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25944 
25945   JITTER_INSTRUCTION_PROLOG_(nrot, nrot, hot)
25946   {
25947     /* This specialized instruction is not a replacement. */
25948 #   undef JITTER_BRANCH_FAST
25949 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25950 #   undef JITTER_BRANCH_FAST_IF_ZERO
25951 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25952 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25953 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25954 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25955 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25956 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25957 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25958 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25959 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25960 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25961 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25962 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25963 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25964 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25965 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25966 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25967 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25968 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25969 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25970 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25971 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25972 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25973 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25974 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25975 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25976 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25977 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25978 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25979 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25980 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25981 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25982 #   undef JITTER_BRANCH_FAST_IF_AND
25983 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25984 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25985 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25986 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25987 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25988 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25989 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25990 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25991 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25992 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25993 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25994 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25995 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25996 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25997 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25998 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25999 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26000 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26001 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26002 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26003 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26004 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26005 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26006 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26007 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26008 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26009 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26010 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26011 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26012 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       178
26013 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nrot
26014 
26015 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nrot
26016 
26017   /* The residual arity for this instruction does not depend on fast labels. */
26018   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26019 
26020 
26021 #if defined (JITTER_PROFILE_SAMPLE)
26022   JITTER_PROFILE_SAMPLE_UPDATE
26023      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26024       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26025   /* Force the compiler not move sample-profiling instrumentation
26026      beyond this point; this way the actual user code is timed.
26027      This is still not perfect, as residuals are materialised before
26028      we arrive here, but should be adequate at least for slow VM
26029      instructions. */
26030   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26031 #endif
26032 #if defined (JITTER_PROFILE_COUNT)
26033   /* Notice that, differently from the code above, this
26034      instrumentation code *can* be reordered freely: as long as a
26035      VM instruction is counted, the count increment can be placed
26036      anyehere.  Let GCC move this code and possibly achieve better
26037      throughput by exploiting instruction-level parallelism and
26038      therefore approximate more closely a non-profiled build. */
26039   JITTER_PROFILE_COUNT_UPDATE
26040      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26041       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26042 #endif
26043 
26044 /* User-specified code, instruction-beginning-c part: beginning. */
26045 
26046 /* User-specified code, instruction-beginning-c part: end */
26047 
26048 
26049     /* User code for nrot . */
26050 #line 2075 "../../libpoke/pvm.jitter"
26051 
26052     JITTER_MROT_STACK ();
26053 
26054     /* End of the user code for nrot . */
26055 
26056 /* User-specified code, instruction-end-c part: beginning. */
26057 
26058 /* User-specified code, instruction-end-c part: end */
26059 
26060     /* Undefine the nrot argument macros so they can't be used
26061        by mistake in the instruction body coming next. */
26062 
26063 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26064 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26065 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26066 
26067   }
26068  JITTER_INSTRUCTION_EPILOG_(nrot, nrot, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26069 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26070 
26071   JITTER_INSTRUCTION_PROLOG_(ogetbt, ogetbt, hot)
26072   {
26073     /* This specialized instruction is not a replacement. */
26074 #   undef JITTER_BRANCH_FAST
26075 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26076 #   undef JITTER_BRANCH_FAST_IF_ZERO
26077 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26078 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26079 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26080 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26081 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26082 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26083 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26084 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26085 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26086 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26087 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26088 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26089 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26090 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26091 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26092 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26093 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26094 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26095 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26096 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26097 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26098 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26099 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26100 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26101 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26102 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26103 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26104 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26105 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26106 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26107 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26108 #   undef JITTER_BRANCH_FAST_IF_AND
26109 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26110 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26111 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26112 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26113 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26114 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26115 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26116 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26117 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26118 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26119 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26120 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26121 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26122 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26123 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26124 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26125 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26126 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26127 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26128 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26129 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26130 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26131 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26132 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26133 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26134 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26135 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26136 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26137 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26138 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       179
26139 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ogetbt
26140 
26141 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ogetbt
26142 
26143   /* The residual arity for this instruction does not depend on fast labels. */
26144   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26145 
26146 
26147 #if defined (JITTER_PROFILE_SAMPLE)
26148   JITTER_PROFILE_SAMPLE_UPDATE
26149      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26150       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26151   /* Force the compiler not move sample-profiling instrumentation
26152      beyond this point; this way the actual user code is timed.
26153      This is still not perfect, as residuals are materialised before
26154      we arrive here, but should be adequate at least for slow VM
26155      instructions. */
26156   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26157 #endif
26158 #if defined (JITTER_PROFILE_COUNT)
26159   /* Notice that, differently from the code above, this
26160      instrumentation code *can* be reordered freely: as long as a
26161      VM instruction is counted, the count increment can be placed
26162      anyehere.  Let GCC move this code and possibly achieve better
26163      throughput by exploiting instruction-level parallelism and
26164      therefore approximate more closely a non-profiled build. */
26165   JITTER_PROFILE_COUNT_UPDATE
26166      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26167       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26168 #endif
26169 
26170 /* User-specified code, instruction-beginning-c part: beginning. */
26171 
26172 /* User-specified code, instruction-beginning-c part: end */
26173 
26174 
26175     /* User code for ogetbt . */
26176 #line 4649 "../../libpoke/pvm.jitter"
26177 
26178     JITTER_PUSH_STACK (PVM_VAL_OFF_BASE_TYPE (JITTER_TOP_STACK ()));
26179 
26180     /* End of the user code for ogetbt . */
26181 
26182 /* User-specified code, instruction-end-c part: beginning. */
26183 
26184 /* User-specified code, instruction-end-c part: end */
26185 
26186     /* Undefine the ogetbt argument macros so they can't be used
26187        by mistake in the instruction body coming next. */
26188 
26189 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26190 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26191 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26192 
26193   }
26194  JITTER_INSTRUCTION_EPILOG_(ogetbt, ogetbt, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26195 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26196 
26197   JITTER_INSTRUCTION_PROLOG_(ogetm, ogetm, hot)
26198   {
26199     /* This specialized instruction is not a replacement. */
26200 #   undef JITTER_BRANCH_FAST
26201 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26202 #   undef JITTER_BRANCH_FAST_IF_ZERO
26203 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26204 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26205 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26206 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26207 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26208 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26209 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26210 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26211 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26212 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26213 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26214 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26215 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26216 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26217 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26218 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26219 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26220 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26221 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26222 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26223 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26224 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26225 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26226 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26227 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26228 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26229 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26230 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26231 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26232 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26233 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26234 #   undef JITTER_BRANCH_FAST_IF_AND
26235 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26236 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26237 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26238 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26239 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26240 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26241 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26242 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26243 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26244 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26245 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26246 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26247 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26248 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26249 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26250 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26251 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26252 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26253 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26254 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26255 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26256 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26257 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26258 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26259 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26260 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26261 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26262 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26263 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26264 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       180
26265 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ogetm
26266 
26267 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ogetm
26268 
26269   /* The residual arity for this instruction does not depend on fast labels. */
26270   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26271 
26272 
26273 #if defined (JITTER_PROFILE_SAMPLE)
26274   JITTER_PROFILE_SAMPLE_UPDATE
26275      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26276       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26277   /* Force the compiler not move sample-profiling instrumentation
26278      beyond this point; this way the actual user code is timed.
26279      This is still not perfect, as residuals are materialised before
26280      we arrive here, but should be adequate at least for slow VM
26281      instructions. */
26282   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26283 #endif
26284 #if defined (JITTER_PROFILE_COUNT)
26285   /* Notice that, differently from the code above, this
26286      instrumentation code *can* be reordered freely: as long as a
26287      VM instruction is counted, the count increment can be placed
26288      anyehere.  Let GCC move this code and possibly achieve better
26289      throughput by exploiting instruction-level parallelism and
26290      therefore approximate more closely a non-profiled build. */
26291   JITTER_PROFILE_COUNT_UPDATE
26292      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26293       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26294 #endif
26295 
26296 /* User-specified code, instruction-beginning-c part: beginning. */
26297 
26298 /* User-specified code, instruction-beginning-c part: end */
26299 
26300 
26301     /* User code for ogetm . */
26302 #line 4610 "../../libpoke/pvm.jitter"
26303 
26304    JITTER_PUSH_STACK (PVM_VAL_OFF_MAGNITUDE (JITTER_TOP_STACK ()));
26305 
26306     /* End of the user code for ogetm . */
26307 
26308 /* User-specified code, instruction-end-c part: beginning. */
26309 
26310 /* User-specified code, instruction-end-c part: end */
26311 
26312     /* Undefine the ogetm argument macros so they can't be used
26313        by mistake in the instruction body coming next. */
26314 
26315 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26316 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26317 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26318 
26319   }
26320  JITTER_INSTRUCTION_EPILOG_(ogetm, ogetm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26321 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26322 
26323   JITTER_INSTRUCTION_PROLOG_(ogetu, ogetu, hot)
26324   {
26325     /* This specialized instruction is not a replacement. */
26326 #   undef JITTER_BRANCH_FAST
26327 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26328 #   undef JITTER_BRANCH_FAST_IF_ZERO
26329 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26330 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26331 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26332 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26333 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26334 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26335 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26336 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26337 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26338 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26339 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26340 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26341 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26342 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26343 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26344 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26345 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26346 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26347 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26348 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26349 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26350 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26351 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26352 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26353 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26354 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26355 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26356 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26357 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26358 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26359 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26360 #   undef JITTER_BRANCH_FAST_IF_AND
26361 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26362 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26363 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26364 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26365 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26366 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26367 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26368 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26369 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26370 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26371 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26372 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26373 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26374 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26375 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26376 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26377 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26378 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26379 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26380 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26381 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26382 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26383 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26384 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26385 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26386 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26387 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26388 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26389 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26390 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       181
26391 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ogetu
26392 
26393 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ogetu
26394 
26395   /* The residual arity for this instruction does not depend on fast labels. */
26396   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26397 
26398 
26399 #if defined (JITTER_PROFILE_SAMPLE)
26400   JITTER_PROFILE_SAMPLE_UPDATE
26401      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26402       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26403   /* Force the compiler not move sample-profiling instrumentation
26404      beyond this point; this way the actual user code is timed.
26405      This is still not perfect, as residuals are materialised before
26406      we arrive here, but should be adequate at least for slow VM
26407      instructions. */
26408   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26409 #endif
26410 #if defined (JITTER_PROFILE_COUNT)
26411   /* Notice that, differently from the code above, this
26412      instrumentation code *can* be reordered freely: as long as a
26413      VM instruction is counted, the count increment can be placed
26414      anyehere.  Let GCC move this code and possibly achieve better
26415      throughput by exploiting instruction-level parallelism and
26416      therefore approximate more closely a non-profiled build. */
26417   JITTER_PROFILE_COUNT_UPDATE
26418      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26419       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26420 #endif
26421 
26422 /* User-specified code, instruction-beginning-c part: beginning. */
26423 
26424 /* User-specified code, instruction-beginning-c part: end */
26425 
26426 
26427     /* User code for ogetu . */
26428 #line 4637 "../../libpoke/pvm.jitter"
26429 
26430     JITTER_PUSH_STACK (PVM_VAL_OFF_UNIT (JITTER_TOP_STACK ()));
26431 
26432     /* End of the user code for ogetu . */
26433 
26434 /* User-specified code, instruction-end-c part: beginning. */
26435 
26436 /* User-specified code, instruction-end-c part: end */
26437 
26438     /* Undefine the ogetu argument macros so they can't be used
26439        by mistake in the instruction body coming next. */
26440 
26441 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26442 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26443 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26444 
26445   }
26446  JITTER_INSTRUCTION_EPILOG_(ogetu, ogetu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26447 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26448 
26449   JITTER_INSTRUCTION_PROLOG_(open, open, hot)
26450   {
26451     /* This specialized instruction is not a replacement. */
26452 #   undef JITTER_BRANCH_FAST
26453 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26454 #   undef JITTER_BRANCH_FAST_IF_ZERO
26455 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26456 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26457 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26458 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26459 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26460 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26461 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26462 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26463 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26464 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26465 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26466 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26467 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26468 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26469 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26470 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26471 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26472 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26473 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26474 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26475 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26476 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26477 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26478 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26479 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26480 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26481 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26482 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26483 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26484 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26485 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26486 #   undef JITTER_BRANCH_FAST_IF_AND
26487 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26488 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26489 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26490 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26491 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26492 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26493 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26494 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26495 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26496 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26497 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26498 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26499 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26500 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26501 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26502 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26503 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26504 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26505 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26506 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26507 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26508 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26509 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26510 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26511 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26512 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26513 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26514 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26515 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26516 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       182
26517 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         open
26518 
26519 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME open
26520 
26521   /* The residual arity for this instruction does not depend on fast labels. */
26522   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26523 
26524 
26525 #if defined (JITTER_PROFILE_SAMPLE)
26526   JITTER_PROFILE_SAMPLE_UPDATE
26527      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26528       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26529   /* Force the compiler not move sample-profiling instrumentation
26530      beyond this point; this way the actual user code is timed.
26531      This is still not perfect, as residuals are materialised before
26532      we arrive here, but should be adequate at least for slow VM
26533      instructions. */
26534   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26535 #endif
26536 #if defined (JITTER_PROFILE_COUNT)
26537   /* Notice that, differently from the code above, this
26538      instrumentation code *can* be reordered freely: as long as a
26539      VM instruction is counted, the count increment can be placed
26540      anyehere.  Let GCC move this code and possibly achieve better
26541      throughput by exploiting instruction-level parallelism and
26542      therefore approximate more closely a non-profiled build. */
26543   JITTER_PROFILE_COUNT_UPDATE
26544      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26545       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26546 #endif
26547 
26548 /* User-specified code, instruction-beginning-c part: beginning. */
26549 
26550 /* User-specified code, instruction-beginning-c part: end */
26551 
26552 
26553     /* User code for open . */
26554 #line 1354 "../../libpoke/pvm.jitter"
26555 
26556      char *filename = PVM_VAL_STR (JITTER_UNDER_TOP_STACK ());
26557      uint64_t flags = PVM_VAL_ULONG (JITTER_TOP_STACK ());
26558 
26559      int ret = ios_open (filename, flags, 0);
26560 
26561      if (ret == IOS_EFLAGS)
26562        PVM_RAISE_DFL (PVM_E_IOFLAGS);
26563      else if (ret < IOS_OK)
26564        PVM_RAISE_DFL (PVM_E_IO);
26565 
26566      JITTER_DROP_STACK ();
26567      JITTER_TOP_STACK () = PVM_MAKE_INT (ret, 32);
26568 
26569     /* End of the user code for open . */
26570 
26571 /* User-specified code, instruction-end-c part: beginning. */
26572 
26573 /* User-specified code, instruction-end-c part: end */
26574 
26575     /* Undefine the open argument macros so they can't be used
26576        by mistake in the instruction body coming next. */
26577 
26578 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26579 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26580 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26581 
26582   }
26583  JITTER_INSTRUCTION_EPILOG_(open, open, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26584 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26585 
26586   JITTER_INSTRUCTION_PROLOG_(or, or, hot)
26587   {
26588     /* This specialized instruction is not a replacement. */
26589 #   undef JITTER_BRANCH_FAST
26590 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26591 #   undef JITTER_BRANCH_FAST_IF_ZERO
26592 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26593 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26594 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26595 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26596 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26597 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26598 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26599 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26600 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26601 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26602 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26603 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26604 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26605 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26606 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26607 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26608 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26609 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26610 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26611 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26612 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26613 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26614 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26615 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26616 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26617 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26618 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26619 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26620 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26621 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26622 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26623 #   undef JITTER_BRANCH_FAST_IF_AND
26624 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26625 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26626 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26627 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26628 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26629 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26630 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26631 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26632 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26633 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26634 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26635 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26636 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26637 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26638 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26639 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26640 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26641 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26642 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26643 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26644 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26645 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26646 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26647 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26648 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26649 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26650 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26651 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26652 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26653 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       183
26654 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         or
26655 
26656 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME or
26657 
26658   /* The residual arity for this instruction does not depend on fast labels. */
26659   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26660 
26661 
26662 #if defined (JITTER_PROFILE_SAMPLE)
26663   JITTER_PROFILE_SAMPLE_UPDATE
26664      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26665       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26666   /* Force the compiler not move sample-profiling instrumentation
26667      beyond this point; this way the actual user code is timed.
26668      This is still not perfect, as residuals are materialised before
26669      we arrive here, but should be adequate at least for slow VM
26670      instructions. */
26671   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26672 #endif
26673 #if defined (JITTER_PROFILE_COUNT)
26674   /* Notice that, differently from the code above, this
26675      instrumentation code *can* be reordered freely: as long as a
26676      VM instruction is counted, the count increment can be placed
26677      anyehere.  Let GCC move this code and possibly achieve better
26678      throughput by exploiting instruction-level parallelism and
26679      therefore approximate more closely a non-profiled build. */
26680   JITTER_PROFILE_COUNT_UPDATE
26681      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26682       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26683 #endif
26684 
26685 /* User-specified code, instruction-beginning-c part: beginning. */
26686 
26687 /* User-specified code, instruction-beginning-c part: end */
26688 
26689 
26690     /* User code for or . */
26691 #line 3154 "../../libpoke/pvm.jitter"
26692 
26693     PVM_BOOL_BINOP (INT, ||);
26694 
26695     /* End of the user code for or . */
26696 
26697 /* User-specified code, instruction-end-c part: beginning. */
26698 
26699 /* User-specified code, instruction-end-c part: end */
26700 
26701     /* Undefine the or argument macros so they can't be used
26702        by mistake in the instruction body coming next. */
26703 
26704 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26705 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26706 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26707 
26708   }
26709  JITTER_INSTRUCTION_EPILOG_(or, or, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26710 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26711 
26712   JITTER_INSTRUCTION_PROLOG_(osetm, osetm, hot)
26713   {
26714     /* This specialized instruction is not a replacement. */
26715 #   undef JITTER_BRANCH_FAST
26716 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26717 #   undef JITTER_BRANCH_FAST_IF_ZERO
26718 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26719 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26720 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26721 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26722 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26723 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26724 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26725 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26726 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26727 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26728 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26729 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26730 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26731 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26732 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26733 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26734 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26735 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26736 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26737 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26738 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26739 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26740 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26741 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26742 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26743 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26744 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26745 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26746 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26747 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26748 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26749 #   undef JITTER_BRANCH_FAST_IF_AND
26750 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26751 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26752 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26753 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26754 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26755 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26756 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26757 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26758 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26759 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26760 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26761 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26762 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26763 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26764 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26765 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26766 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26767 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26768 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26769 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26770 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26771 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26772 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26773 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26774 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26775 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26776 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26777 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26778 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26779 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       184
26780 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         osetm
26781 
26782 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME osetm
26783 
26784   /* The residual arity for this instruction does not depend on fast labels. */
26785   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26786 
26787 
26788 #if defined (JITTER_PROFILE_SAMPLE)
26789   JITTER_PROFILE_SAMPLE_UPDATE
26790      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26791       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26792   /* Force the compiler not move sample-profiling instrumentation
26793      beyond this point; this way the actual user code is timed.
26794      This is still not perfect, as residuals are materialised before
26795      we arrive here, but should be adequate at least for slow VM
26796      instructions. */
26797   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26798 #endif
26799 #if defined (JITTER_PROFILE_COUNT)
26800   /* Notice that, differently from the code above, this
26801      instrumentation code *can* be reordered freely: as long as a
26802      VM instruction is counted, the count increment can be placed
26803      anyehere.  Let GCC move this code and possibly achieve better
26804      throughput by exploiting instruction-level parallelism and
26805      therefore approximate more closely a non-profiled build. */
26806   JITTER_PROFILE_COUNT_UPDATE
26807      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26808       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26809 #endif
26810 
26811 /* User-specified code, instruction-beginning-c part: beginning. */
26812 
26813 /* User-specified code, instruction-beginning-c part: end */
26814 
26815 
26816     /* User code for osetm . */
26817 #line 4623 "../../libpoke/pvm.jitter"
26818 
26819    PVM_VAL_OFF_MAGNITUDE (JITTER_UNDER_TOP_STACK ())
26820     =  JITTER_TOP_STACK ();
26821    JITTER_DROP_STACK ();
26822 
26823     /* End of the user code for osetm . */
26824 
26825 /* User-specified code, instruction-end-c part: beginning. */
26826 
26827 /* User-specified code, instruction-end-c part: end */
26828 
26829     /* Undefine the osetm argument macros so they can't be used
26830        by mistake in the instruction body coming next. */
26831 
26832 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26833 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26834 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26835 
26836   }
26837  JITTER_INSTRUCTION_EPILOG_(osetm, osetm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26838 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26839 
26840   JITTER_INSTRUCTION_PROLOG_(over, over, hot)
26841   {
26842     /* This specialized instruction is not a replacement. */
26843 #   undef JITTER_BRANCH_FAST
26844 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26845 #   undef JITTER_BRANCH_FAST_IF_ZERO
26846 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26847 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26848 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26849 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26850 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26851 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26852 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26853 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26854 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26855 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26856 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26857 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26858 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26859 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26860 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26861 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26862 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26863 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26864 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26865 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26866 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26867 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26868 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26869 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26870 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26871 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26872 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26873 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26874 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26875 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26876 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26877 #   undef JITTER_BRANCH_FAST_IF_AND
26878 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26879 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26880 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26881 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26882 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26883 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26884 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26885 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26886 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26887 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26888 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26889 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26890 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26891 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26892 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26893 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26894 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26895 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26896 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26897 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26898 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26899 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26900 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26901 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26902 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26903 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26904 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26905 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26906 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26907 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       185
26908 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         over
26909 
26910 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME over
26911 
26912   /* The residual arity for this instruction does not depend on fast labels. */
26913   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26914 
26915 
26916 #if defined (JITTER_PROFILE_SAMPLE)
26917   JITTER_PROFILE_SAMPLE_UPDATE
26918      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26919       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26920   /* Force the compiler not move sample-profiling instrumentation
26921      beyond this point; this way the actual user code is timed.
26922      This is still not perfect, as residuals are materialised before
26923      we arrive here, but should be adequate at least for slow VM
26924      instructions. */
26925   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26926 #endif
26927 #if defined (JITTER_PROFILE_COUNT)
26928   /* Notice that, differently from the code above, this
26929      instrumentation code *can* be reordered freely: as long as a
26930      VM instruction is counted, the count increment can be placed
26931      anyehere.  Let GCC move this code and possibly achieve better
26932      throughput by exploiting instruction-level parallelism and
26933      therefore approximate more closely a non-profiled build. */
26934   JITTER_PROFILE_COUNT_UPDATE
26935      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26936       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26937 #endif
26938 
26939 /* User-specified code, instruction-beginning-c part: beginning. */
26940 
26941 /* User-specified code, instruction-beginning-c part: end */
26942 
26943 
26944     /* User code for over . */
26945 #line 2050 "../../libpoke/pvm.jitter"
26946 
26947     JITTER_PUSH_STACK (JITTER_UNDER_TOP_STACK ());
26948 
26949     /* End of the user code for over . */
26950 
26951 /* User-specified code, instruction-end-c part: beginning. */
26952 
26953 /* User-specified code, instruction-end-c part: end */
26954 
26955     /* Undefine the over argument macros so they can't be used
26956        by mistake in the instruction body coming next. */
26957 
26958 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26959 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26960 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26961 
26962   }
26963  JITTER_INSTRUCTION_EPILOG_(over, over, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26964 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26965 
26966   JITTER_INSTRUCTION_PROLOG_(pec, pec, hot)
26967   {
26968     /* This specialized instruction is not a replacement. */
26969 #   undef JITTER_BRANCH_FAST
26970 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26971 #   undef JITTER_BRANCH_FAST_IF_ZERO
26972 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26973 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26974 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26975 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26976 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26977 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26978 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26979 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26980 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26981 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26982 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26983 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26984 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26985 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26986 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26987 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26988 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26989 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26990 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26991 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26992 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26993 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26994 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26995 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26996 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26997 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26998 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26999 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27000 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27001 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27002 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27003 #   undef JITTER_BRANCH_FAST_IF_AND
27004 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27005 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27006 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27007 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27008 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27009 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27010 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27011 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27012 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27013 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27014 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27015 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27016 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27017 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27018 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27019 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27020 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27021 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27022 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27023 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27024 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27025 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27026 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27027 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27028 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27029 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27030 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27031 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27032 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27033 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       186
27034 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pec
27035 
27036 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pec
27037 
27038   /* The residual arity for this instruction does not depend on fast labels. */
27039   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27040 
27041 
27042 #if defined (JITTER_PROFILE_SAMPLE)
27043   JITTER_PROFILE_SAMPLE_UPDATE
27044      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27045       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27046   /* Force the compiler not move sample-profiling instrumentation
27047      beyond this point; this way the actual user code is timed.
27048      This is still not perfect, as residuals are materialised before
27049      we arrive here, but should be adequate at least for slow VM
27050      instructions. */
27051   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27052 #endif
27053 #if defined (JITTER_PROFILE_COUNT)
27054   /* Notice that, differently from the code above, this
27055      instrumentation code *can* be reordered freely: as long as a
27056      VM instruction is counted, the count increment can be placed
27057      anyehere.  Let GCC move this code and possibly achieve better
27058      throughput by exploiting instruction-level parallelism and
27059      therefore approximate more closely a non-profiled build. */
27060   JITTER_PROFILE_COUNT_UPDATE
27061      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27062       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27063 #endif
27064 
27065 /* User-specified code, instruction-beginning-c part: beginning. */
27066 
27067 /* User-specified code, instruction-beginning-c part: end */
27068 
27069 
27070     /* User code for pec . */
27071 #line 1735 "../../libpoke/pvm.jitter"
27072 
27073     pvm_val cls = JITTER_TOP_STACK ();
27074     PVM_VAL_CLS_ENV (cls) = jitter_state_runtime.env;
27075 
27076     /* End of the user code for pec . */
27077 
27078 /* User-specified code, instruction-end-c part: beginning. */
27079 
27080 /* User-specified code, instruction-end-c part: end */
27081 
27082     /* Undefine the pec argument macros so they can't be used
27083        by mistake in the instruction body coming next. */
27084 
27085 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27086 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27087 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27088 
27089   }
27090  JITTER_INSTRUCTION_EPILOG_(pec, pec, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27091 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27092 
27093   JITTER_INSTRUCTION_PROLOG_(peekdi/nR, peekdi__nR, cold)
27094   {
27095     /* This specialized instruction is not a replacement. */
27096 #   undef JITTER_BRANCH_FAST
27097 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27098 #   undef JITTER_BRANCH_FAST_IF_ZERO
27099 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27100 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27101 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27102 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27103 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27104 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27105 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27106 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27107 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27108 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27109 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27110 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27111 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27112 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27113 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27114 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27115 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27116 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27117 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27118 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27119 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27120 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27121 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27122 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27123 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27124 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27125 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27126 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27127 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27128 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27129 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27130 #   undef JITTER_BRANCH_FAST_IF_AND
27131 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27132 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27133 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27134 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27135 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27136 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27137 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27138 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27139 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27140 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27141 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27142 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27143 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27144 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27145 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27146 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27147 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27148 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27149 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27150 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27151 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27152 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27153 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27154 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27155 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27156 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27157 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27158 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27159 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27160 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       187
27161 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peekdi/nR
27162 
27163 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peekdi__nR
27164 
27165   /* The residual arity for this instruction does not depend on fast labels. */
27166   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
27167 
27168     /* The 0th argument is a residual literal. */
27169 #if defined(JITTER_DISPATCH_NO_THREADING)
27170 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27171     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27172 #elif defined (JITTER_REPLICATE)
27173 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27174 #else
27175 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27176 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27177 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27178 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27179 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27180 #   define JITTER_ARGF0 JITTER_ARGP0
27181 
27182 
27183 #if defined (JITTER_PROFILE_SAMPLE)
27184   JITTER_PROFILE_SAMPLE_UPDATE
27185      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27186       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27187   /* Force the compiler not move sample-profiling instrumentation
27188      beyond this point; this way the actual user code is timed.
27189      This is still not perfect, as residuals are materialised before
27190      we arrive here, but should be adequate at least for slow VM
27191      instructions. */
27192   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27193 #endif
27194 #if defined (JITTER_PROFILE_COUNT)
27195   /* Notice that, differently from the code above, this
27196      instrumentation code *can* be reordered freely: as long as a
27197      VM instruction is counted, the count increment can be placed
27198      anyehere.  Let GCC move this code and possibly achieve better
27199      throughput by exploiting instruction-level parallelism and
27200      therefore approximate more closely a non-profiled build. */
27201   JITTER_PROFILE_COUNT_UPDATE
27202      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27203       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27204 #endif
27205 
27206 /* User-specified code, instruction-beginning-c part: beginning. */
27207 
27208 /* User-specified code, instruction-beginning-c part: end */
27209 
27210 
27211     /* User code for peekdi/nR . */
27212 #line 5315 "../../libpoke/pvm.jitter"
27213 
27214     PVM_PEEK (int, int, jitter_state_runtime.nenc, jitter_state_runtime.endian,
27215               JITTER_ARGN0, PVM_IOS_ARGS_INT);
27216 
27217     /* End of the user code for peekdi/nR . */
27218 
27219 /* User-specified code, instruction-end-c part: beginning. */
27220 
27221 /* User-specified code, instruction-end-c part: end */
27222 
27223     /* Undefine the peekdi/nR argument macros so they can't be used
27224        by mistake in the instruction body coming next. */
27225 #   undef JITTER_SLOW_REGISTER_OFFSET0
27226 #   undef JITTER_ARG0
27227 #   undef JITTER_ARGN0
27228 #   undef JITTER_ARGU0
27229 #   undef JITTER_ARGP0
27230 #   undef JITTER_ARGF0
27231 
27232 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27233 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27234 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27235 
27236   }
27237  JITTER_INSTRUCTION_EPILOG_(peekdi/nR, peekdi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27238 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27239 
27240   JITTER_INSTRUCTION_PROLOG_(peekdiu/nR, peekdiu__nR, cold)
27241   {
27242     /* This specialized instruction is not a replacement. */
27243 #   undef JITTER_BRANCH_FAST
27244 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27245 #   undef JITTER_BRANCH_FAST_IF_ZERO
27246 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27247 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27248 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27249 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27250 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27251 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27252 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27253 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27254 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27255 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27256 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27257 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27258 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27259 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27260 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27261 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27262 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27263 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27264 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27265 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27266 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27267 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27268 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27269 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27270 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27271 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27272 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27273 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27274 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27275 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27276 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27277 #   undef JITTER_BRANCH_FAST_IF_AND
27278 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27279 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27280 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27281 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27282 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27283 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27284 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27285 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27286 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27287 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27288 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27289 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27290 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27291 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27292 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27293 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27294 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27295 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27296 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27297 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27298 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27299 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27300 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27301 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27302 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27303 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27304 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27305 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27306 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27307 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       188
27308 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peekdiu/nR
27309 
27310 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peekdiu__nR
27311 
27312   /* The residual arity for this instruction does not depend on fast labels. */
27313   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
27314 
27315     /* The 0th argument is a residual literal. */
27316 #if defined(JITTER_DISPATCH_NO_THREADING)
27317 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27318     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27319 #elif defined (JITTER_REPLICATE)
27320 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27321 #else
27322 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27323 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27324 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27325 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27326 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27327 #   define JITTER_ARGF0 JITTER_ARGP0
27328 
27329 
27330 #if defined (JITTER_PROFILE_SAMPLE)
27331   JITTER_PROFILE_SAMPLE_UPDATE
27332      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27333       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27334   /* Force the compiler not move sample-profiling instrumentation
27335      beyond this point; this way the actual user code is timed.
27336      This is still not perfect, as residuals are materialised before
27337      we arrive here, but should be adequate at least for slow VM
27338      instructions. */
27339   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27340 #endif
27341 #if defined (JITTER_PROFILE_COUNT)
27342   /* Notice that, differently from the code above, this
27343      instrumentation code *can* be reordered freely: as long as a
27344      VM instruction is counted, the count increment can be placed
27345      anyehere.  Let GCC move this code and possibly achieve better
27346      throughput by exploiting instruction-level parallelism and
27347      therefore approximate more closely a non-profiled build. */
27348   JITTER_PROFILE_COUNT_UPDATE
27349      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27350       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27351 #endif
27352 
27353 /* User-specified code, instruction-beginning-c part: beginning. */
27354 
27355 /* User-specified code, instruction-beginning-c part: end */
27356 
27357 
27358     /* User code for peekdiu/nR . */
27359 #line 5329 "../../libpoke/pvm.jitter"
27360 
27361     PVM_PEEK (uint, uint, jitter_state_runtime.nenc, jitter_state_runtime.endian,
27362               JITTER_ARGN0, PVM_IOS_ARGS_UINT);
27363 
27364     /* End of the user code for peekdiu/nR . */
27365 
27366 /* User-specified code, instruction-end-c part: beginning. */
27367 
27368 /* User-specified code, instruction-end-c part: end */
27369 
27370     /* Undefine the peekdiu/nR argument macros so they can't be used
27371        by mistake in the instruction body coming next. */
27372 #   undef JITTER_SLOW_REGISTER_OFFSET0
27373 #   undef JITTER_ARG0
27374 #   undef JITTER_ARGN0
27375 #   undef JITTER_ARGU0
27376 #   undef JITTER_ARGP0
27377 #   undef JITTER_ARGF0
27378 
27379 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27380 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27381 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27382 
27383   }
27384  JITTER_INSTRUCTION_EPILOG_(peekdiu/nR, peekdiu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27385 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27386 
27387   JITTER_INSTRUCTION_PROLOG_(peekdl/nR, peekdl__nR, cold)
27388   {
27389     /* This specialized instruction is not a replacement. */
27390 #   undef JITTER_BRANCH_FAST
27391 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27392 #   undef JITTER_BRANCH_FAST_IF_ZERO
27393 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27394 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27395 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27396 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27397 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27398 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27399 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27400 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27401 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27402 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27403 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27404 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27405 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27406 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27407 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27408 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27409 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27410 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27411 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27412 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27413 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27414 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27415 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27416 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27417 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27418 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27419 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27420 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27421 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27422 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27423 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27424 #   undef JITTER_BRANCH_FAST_IF_AND
27425 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27426 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27427 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27428 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27429 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27430 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27431 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27432 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27433 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27434 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27435 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27436 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27437 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27438 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27439 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27440 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27441 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27442 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27443 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27444 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27445 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27446 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27447 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27448 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27449 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27450 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27451 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27452 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27453 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27454 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       189
27455 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peekdl/nR
27456 
27457 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peekdl__nR
27458 
27459   /* The residual arity for this instruction does not depend on fast labels. */
27460   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
27461 
27462     /* The 0th argument is a residual literal. */
27463 #if defined(JITTER_DISPATCH_NO_THREADING)
27464 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27465     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27466 #elif defined (JITTER_REPLICATE)
27467 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27468 #else
27469 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27470 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27471 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27472 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27473 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27474 #   define JITTER_ARGF0 JITTER_ARGP0
27475 
27476 
27477 #if defined (JITTER_PROFILE_SAMPLE)
27478   JITTER_PROFILE_SAMPLE_UPDATE
27479      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27480       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27481   /* Force the compiler not move sample-profiling instrumentation
27482      beyond this point; this way the actual user code is timed.
27483      This is still not perfect, as residuals are materialised before
27484      we arrive here, but should be adequate at least for slow VM
27485      instructions. */
27486   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27487 #endif
27488 #if defined (JITTER_PROFILE_COUNT)
27489   /* Notice that, differently from the code above, this
27490      instrumentation code *can* be reordered freely: as long as a
27491      VM instruction is counted, the count increment can be placed
27492      anyehere.  Let GCC move this code and possibly achieve better
27493      throughput by exploiting instruction-level parallelism and
27494      therefore approximate more closely a non-profiled build. */
27495   JITTER_PROFILE_COUNT_UPDATE
27496      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27497       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27498 #endif
27499 
27500 /* User-specified code, instruction-beginning-c part: beginning. */
27501 
27502 /* User-specified code, instruction-beginning-c part: end */
27503 
27504 
27505     /* User code for peekdl/nR . */
27506 #line 5343 "../../libpoke/pvm.jitter"
27507 
27508     PVM_PEEK (long, int, jitter_state_runtime.nenc, jitter_state_runtime.endian,
27509               JITTER_ARGN0, PVM_IOS_ARGS_INT);
27510 
27511     /* End of the user code for peekdl/nR . */
27512 
27513 /* User-specified code, instruction-end-c part: beginning. */
27514 
27515 /* User-specified code, instruction-end-c part: end */
27516 
27517     /* Undefine the peekdl/nR argument macros so they can't be used
27518        by mistake in the instruction body coming next. */
27519 #   undef JITTER_SLOW_REGISTER_OFFSET0
27520 #   undef JITTER_ARG0
27521 #   undef JITTER_ARGN0
27522 #   undef JITTER_ARGU0
27523 #   undef JITTER_ARGP0
27524 #   undef JITTER_ARGF0
27525 
27526 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27527 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27528 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27529 
27530   }
27531  JITTER_INSTRUCTION_EPILOG_(peekdl/nR, peekdl__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27532 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27533 
27534   JITTER_INSTRUCTION_PROLOG_(peekdlu/nR, peekdlu__nR, cold)
27535   {
27536     /* This specialized instruction is not a replacement. */
27537 #   undef JITTER_BRANCH_FAST
27538 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27539 #   undef JITTER_BRANCH_FAST_IF_ZERO
27540 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27541 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27542 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27543 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27544 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27545 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27546 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27547 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27548 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27549 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27550 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27551 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27552 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27553 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27554 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27555 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27556 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27557 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27558 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27559 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27560 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27561 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27562 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27563 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27564 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27565 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27566 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27567 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27568 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27569 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27570 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27571 #   undef JITTER_BRANCH_FAST_IF_AND
27572 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27573 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27574 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27575 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27576 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27577 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27578 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27579 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27580 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27581 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27582 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27583 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27584 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27585 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27586 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27587 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27588 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27589 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27590 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27591 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27592 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27593 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27594 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27595 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27596 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27597 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27598 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27599 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27600 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27601 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       190
27602 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peekdlu/nR
27603 
27604 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peekdlu__nR
27605 
27606   /* The residual arity for this instruction does not depend on fast labels. */
27607   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
27608 
27609     /* The 0th argument is a residual literal. */
27610 #if defined(JITTER_DISPATCH_NO_THREADING)
27611 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27612     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27613 #elif defined (JITTER_REPLICATE)
27614 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27615 #else
27616 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27617 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27618 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27619 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27620 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27621 #   define JITTER_ARGF0 JITTER_ARGP0
27622 
27623 
27624 #if defined (JITTER_PROFILE_SAMPLE)
27625   JITTER_PROFILE_SAMPLE_UPDATE
27626      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27627       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27628   /* Force the compiler not move sample-profiling instrumentation
27629      beyond this point; this way the actual user code is timed.
27630      This is still not perfect, as residuals are materialised before
27631      we arrive here, but should be adequate at least for slow VM
27632      instructions. */
27633   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27634 #endif
27635 #if defined (JITTER_PROFILE_COUNT)
27636   /* Notice that, differently from the code above, this
27637      instrumentation code *can* be reordered freely: as long as a
27638      VM instruction is counted, the count increment can be placed
27639      anyehere.  Let GCC move this code and possibly achieve better
27640      throughput by exploiting instruction-level parallelism and
27641      therefore approximate more closely a non-profiled build. */
27642   JITTER_PROFILE_COUNT_UPDATE
27643      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27644       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27645 #endif
27646 
27647 /* User-specified code, instruction-beginning-c part: beginning. */
27648 
27649 /* User-specified code, instruction-beginning-c part: end */
27650 
27651 
27652     /* User code for peekdlu/nR . */
27653 #line 5357 "../../libpoke/pvm.jitter"
27654 
27655     PVM_PEEK (ulong, uint, jitter_state_runtime.nenc, jitter_state_runtime.endian,
27656               JITTER_ARGN0, PVM_IOS_ARGS_UINT);
27657 
27658     /* End of the user code for peekdlu/nR . */
27659 
27660 /* User-specified code, instruction-end-c part: beginning. */
27661 
27662 /* User-specified code, instruction-end-c part: end */
27663 
27664     /* Undefine the peekdlu/nR argument macros so they can't be used
27665        by mistake in the instruction body coming next. */
27666 #   undef JITTER_SLOW_REGISTER_OFFSET0
27667 #   undef JITTER_ARG0
27668 #   undef JITTER_ARGN0
27669 #   undef JITTER_ARGU0
27670 #   undef JITTER_ARGP0
27671 #   undef JITTER_ARGF0
27672 
27673 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27674 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27675 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27676 
27677   }
27678  JITTER_INSTRUCTION_EPILOG_(peekdlu/nR, peekdlu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27679 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27680 
27681   JITTER_INSTRUCTION_PROLOG_(peeki/nR/nR/nR, peeki__nR__nR__nR, cold)
27682   {
27683     /* This specialized instruction is not a replacement. */
27684 #   undef JITTER_BRANCH_FAST
27685 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27686 #   undef JITTER_BRANCH_FAST_IF_ZERO
27687 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27688 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27689 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27690 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27691 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27692 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27693 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27694 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27695 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27696 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27697 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27698 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27699 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27700 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27701 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27702 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27703 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27704 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27705 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27706 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27707 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27708 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27709 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27710 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27711 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27712 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27713 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27714 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27715 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27716 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27717 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27718 #   undef JITTER_BRANCH_FAST_IF_AND
27719 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27720 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27721 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27722 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27723 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27724 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27725 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27726 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27727 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27728 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27729 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27730 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27731 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27732 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27733 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27734 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27735 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27736 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27737 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27738 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27739 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27740 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27741 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27742 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27743 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27744 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27745 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27746 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27747 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27748 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       191
27749 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peeki/nR/nR/nR
27750 
27751 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peeki__nR__nR__nR
27752 
27753   /* The residual arity for this instruction does not depend on fast labels. */
27754   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
27755 
27756     /* The 0th argument is a residual literal. */
27757 #if defined(JITTER_DISPATCH_NO_THREADING)
27758 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27759     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27760 #elif defined (JITTER_REPLICATE)
27761 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27762 #else
27763 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27764 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27765 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27766 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27767 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27768 #   define JITTER_ARGF0 JITTER_ARGP0
27769 
27770     /* The 1th argument is a residual literal. */
27771 #if defined(JITTER_DISPATCH_NO_THREADING)
27772 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
27773     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
27774 #elif defined (JITTER_REPLICATE)
27775 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
27776 #else
27777 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
27778 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27779 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
27780 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
27781 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
27782 #   define JITTER_ARGF1 JITTER_ARGP1
27783 
27784     /* The 2th argument is a residual literal. */
27785 #if defined(JITTER_DISPATCH_NO_THREADING)
27786 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
27787     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
27788 #elif defined (JITTER_REPLICATE)
27789 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
27790 #else
27791 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
27792 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27793 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
27794 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
27795 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
27796 #   define JITTER_ARGF2 JITTER_ARGP2
27797 
27798 
27799 #if defined (JITTER_PROFILE_SAMPLE)
27800   JITTER_PROFILE_SAMPLE_UPDATE
27801      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27802       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27803   /* Force the compiler not move sample-profiling instrumentation
27804      beyond this point; this way the actual user code is timed.
27805      This is still not perfect, as residuals are materialised before
27806      we arrive here, but should be adequate at least for slow VM
27807      instructions. */
27808   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27809 #endif
27810 #if defined (JITTER_PROFILE_COUNT)
27811   /* Notice that, differently from the code above, this
27812      instrumentation code *can* be reordered freely: as long as a
27813      VM instruction is counted, the count increment can be placed
27814      anyehere.  Let GCC move this code and possibly achieve better
27815      throughput by exploiting instruction-level parallelism and
27816      therefore approximate more closely a non-profiled build. */
27817   JITTER_PROFILE_COUNT_UPDATE
27818      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27819       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27820 #endif
27821 
27822 /* User-specified code, instruction-beginning-c part: beginning. */
27823 
27824 /* User-specified code, instruction-beginning-c part: end */
27825 
27826 
27827     /* User code for peeki/nR/nR/nR . */
27828 #line 5256 "../../libpoke/pvm.jitter"
27829 
27830     PVM_PEEK (int, int, JITTER_ARGN0, JITTER_ARGN1, JITTER_ARGN2,
27831               PVM_IOS_ARGS_INT);
27832 
27833     /* End of the user code for peeki/nR/nR/nR . */
27834 
27835 /* User-specified code, instruction-end-c part: beginning. */
27836 
27837 /* User-specified code, instruction-end-c part: end */
27838 
27839     /* Undefine the peeki/nR/nR/nR argument macros so they can't be used
27840        by mistake in the instruction body coming next. */
27841 #   undef JITTER_SLOW_REGISTER_OFFSET0
27842 #   undef JITTER_ARG0
27843 #   undef JITTER_ARGN0
27844 #   undef JITTER_ARGU0
27845 #   undef JITTER_ARGP0
27846 #   undef JITTER_ARGF0
27847 #   undef JITTER_SLOW_REGISTER_OFFSET1
27848 #   undef JITTER_ARG1
27849 #   undef JITTER_ARGN1
27850 #   undef JITTER_ARGU1
27851 #   undef JITTER_ARGP1
27852 #   undef JITTER_ARGF1
27853 #   undef JITTER_SLOW_REGISTER_OFFSET2
27854 #   undef JITTER_ARG2
27855 #   undef JITTER_ARGN2
27856 #   undef JITTER_ARGU2
27857 #   undef JITTER_ARGP2
27858 #   undef JITTER_ARGF2
27859 
27860 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27861 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27862 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27863 
27864   }
27865  JITTER_INSTRUCTION_EPILOG_(peeki/nR/nR/nR, peeki__nR__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27866 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27867 
27868   JITTER_INSTRUCTION_PROLOG_(peekiu/nR/nR, peekiu__nR__nR, cold)
27869   {
27870     /* This specialized instruction is not a replacement. */
27871 #   undef JITTER_BRANCH_FAST
27872 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27873 #   undef JITTER_BRANCH_FAST_IF_ZERO
27874 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27875 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27876 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27877 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27878 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27879 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27880 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27881 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27882 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27883 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27884 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27885 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27886 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27887 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27888 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27889 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27890 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27891 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27892 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27893 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27894 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27895 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27896 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27897 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27898 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27899 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27900 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27901 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27902 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27903 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27904 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27905 #   undef JITTER_BRANCH_FAST_IF_AND
27906 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27907 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27908 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27909 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27910 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27911 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27912 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27913 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27914 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27915 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27916 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27917 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27918 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27919 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27920 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27921 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27922 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27923 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27924 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27925 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27926 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27927 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27928 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27929 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27930 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27931 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27932 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27933 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27934 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27935 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       192
27936 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peekiu/nR/nR
27937 
27938 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peekiu__nR__nR
27939 
27940   /* The residual arity for this instruction does not depend on fast labels. */
27941   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
27942 
27943     /* The 0th argument is a residual literal. */
27944 #if defined(JITTER_DISPATCH_NO_THREADING)
27945 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27946     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27947 #elif defined (JITTER_REPLICATE)
27948 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27949 #else
27950 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27951 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27952 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27953 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27954 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27955 #   define JITTER_ARGF0 JITTER_ARGP0
27956 
27957     /* The 1th argument is a residual literal. */
27958 #if defined(JITTER_DISPATCH_NO_THREADING)
27959 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
27960     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
27961 #elif defined (JITTER_REPLICATE)
27962 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
27963 #else
27964 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
27965 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27966 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
27967 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
27968 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
27969 #   define JITTER_ARGF1 JITTER_ARGP1
27970 
27971 
27972 #if defined (JITTER_PROFILE_SAMPLE)
27973   JITTER_PROFILE_SAMPLE_UPDATE
27974      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27975       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27976   /* Force the compiler not move sample-profiling instrumentation
27977      beyond this point; this way the actual user code is timed.
27978      This is still not perfect, as residuals are materialised before
27979      we arrive here, but should be adequate at least for slow VM
27980      instructions. */
27981   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27982 #endif
27983 #if defined (JITTER_PROFILE_COUNT)
27984   /* Notice that, differently from the code above, this
27985      instrumentation code *can* be reordered freely: as long as a
27986      VM instruction is counted, the count increment can be placed
27987      anyehere.  Let GCC move this code and possibly achieve better
27988      throughput by exploiting instruction-level parallelism and
27989      therefore approximate more closely a non-profiled build. */
27990   JITTER_PROFILE_COUNT_UPDATE
27991      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27992       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27993 #endif
27994 
27995 /* User-specified code, instruction-beginning-c part: beginning. */
27996 
27997 /* User-specified code, instruction-beginning-c part: end */
27998 
27999 
28000     /* User code for peekiu/nR/nR . */
28001 #line 5271 "../../libpoke/pvm.jitter"
28002 
28003    PVM_PEEK (uint, uint, 0 /* unused */, JITTER_ARGN0, JITTER_ARGN1,
28004              PVM_IOS_ARGS_UINT);
28005 
28006     /* End of the user code for peekiu/nR/nR . */
28007 
28008 /* User-specified code, instruction-end-c part: beginning. */
28009 
28010 /* User-specified code, instruction-end-c part: end */
28011 
28012     /* Undefine the peekiu/nR/nR argument macros so they can't be used
28013        by mistake in the instruction body coming next. */
28014 #   undef JITTER_SLOW_REGISTER_OFFSET0
28015 #   undef JITTER_ARG0
28016 #   undef JITTER_ARGN0
28017 #   undef JITTER_ARGU0
28018 #   undef JITTER_ARGP0
28019 #   undef JITTER_ARGF0
28020 #   undef JITTER_SLOW_REGISTER_OFFSET1
28021 #   undef JITTER_ARG1
28022 #   undef JITTER_ARGN1
28023 #   undef JITTER_ARGU1
28024 #   undef JITTER_ARGP1
28025 #   undef JITTER_ARGF1
28026 
28027 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28028 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28029 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28030 
28031   }
28032  JITTER_INSTRUCTION_EPILOG_(peekiu/nR/nR, peekiu__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28033 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28034 
28035   JITTER_INSTRUCTION_PROLOG_(peekl/nR/nR/nR, peekl__nR__nR__nR, cold)
28036   {
28037     /* This specialized instruction is not a replacement. */
28038 #   undef JITTER_BRANCH_FAST
28039 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28040 #   undef JITTER_BRANCH_FAST_IF_ZERO
28041 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28042 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28043 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28044 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28045 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28046 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28047 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28048 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28049 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28050 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28051 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28052 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28053 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28054 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28055 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28056 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28057 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28058 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28059 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28060 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28061 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28062 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28063 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28064 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28065 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28066 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28067 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28068 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28069 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28070 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28071 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28072 #   undef JITTER_BRANCH_FAST_IF_AND
28073 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28074 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28075 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28076 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28077 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28078 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28079 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28080 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28081 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28082 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28083 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28084 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28085 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28086 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28087 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28088 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28089 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28090 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28091 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28092 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28093 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28094 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28095 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28096 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28097 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28098 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28099 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28100 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28101 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28102 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       193
28103 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peekl/nR/nR/nR
28104 
28105 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peekl__nR__nR__nR
28106 
28107   /* The residual arity for this instruction does not depend on fast labels. */
28108   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
28109 
28110     /* The 0th argument is a residual literal. */
28111 #if defined(JITTER_DISPATCH_NO_THREADING)
28112 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28113     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28114 #elif defined (JITTER_REPLICATE)
28115 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28116 #else
28117 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28118 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28119 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28120 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28121 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28122 #   define JITTER_ARGF0 JITTER_ARGP0
28123 
28124     /* The 1th argument is a residual literal. */
28125 #if defined(JITTER_DISPATCH_NO_THREADING)
28126 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
28127     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
28128 #elif defined (JITTER_REPLICATE)
28129 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
28130 #else
28131 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
28132 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28133 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
28134 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
28135 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
28136 #   define JITTER_ARGF1 JITTER_ARGP1
28137 
28138     /* The 2th argument is a residual literal. */
28139 #if defined(JITTER_DISPATCH_NO_THREADING)
28140 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
28141     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
28142 #elif defined (JITTER_REPLICATE)
28143 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
28144 #else
28145 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
28146 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28147 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
28148 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
28149 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
28150 #   define JITTER_ARGF2 JITTER_ARGP2
28151 
28152 
28153 #if defined (JITTER_PROFILE_SAMPLE)
28154   JITTER_PROFILE_SAMPLE_UPDATE
28155      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28156       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28157   /* Force the compiler not move sample-profiling instrumentation
28158      beyond this point; this way the actual user code is timed.
28159      This is still not perfect, as residuals are materialised before
28160      we arrive here, but should be adequate at least for slow VM
28161      instructions. */
28162   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28163 #endif
28164 #if defined (JITTER_PROFILE_COUNT)
28165   /* Notice that, differently from the code above, this
28166      instrumentation code *can* be reordered freely: as long as a
28167      VM instruction is counted, the count increment can be placed
28168      anyehere.  Let GCC move this code and possibly achieve better
28169      throughput by exploiting instruction-level parallelism and
28170      therefore approximate more closely a non-profiled build. */
28171   JITTER_PROFILE_COUNT_UPDATE
28172      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28173       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28174 #endif
28175 
28176 /* User-specified code, instruction-beginning-c part: beginning. */
28177 
28178 /* User-specified code, instruction-beginning-c part: end */
28179 
28180 
28181     /* User code for peekl/nR/nR/nR . */
28182 #line 5286 "../../libpoke/pvm.jitter"
28183 
28184     PVM_PEEK (long, int, JITTER_ARGN0, JITTER_ARGN1, JITTER_ARGN2,
28185               PVM_IOS_ARGS_INT);
28186 
28187     /* End of the user code for peekl/nR/nR/nR . */
28188 
28189 /* User-specified code, instruction-end-c part: beginning. */
28190 
28191 /* User-specified code, instruction-end-c part: end */
28192 
28193     /* Undefine the peekl/nR/nR/nR argument macros so they can't be used
28194        by mistake in the instruction body coming next. */
28195 #   undef JITTER_SLOW_REGISTER_OFFSET0
28196 #   undef JITTER_ARG0
28197 #   undef JITTER_ARGN0
28198 #   undef JITTER_ARGU0
28199 #   undef JITTER_ARGP0
28200 #   undef JITTER_ARGF0
28201 #   undef JITTER_SLOW_REGISTER_OFFSET1
28202 #   undef JITTER_ARG1
28203 #   undef JITTER_ARGN1
28204 #   undef JITTER_ARGU1
28205 #   undef JITTER_ARGP1
28206 #   undef JITTER_ARGF1
28207 #   undef JITTER_SLOW_REGISTER_OFFSET2
28208 #   undef JITTER_ARG2
28209 #   undef JITTER_ARGN2
28210 #   undef JITTER_ARGU2
28211 #   undef JITTER_ARGP2
28212 #   undef JITTER_ARGF2
28213 
28214 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28215 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28216 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28217 
28218   }
28219  JITTER_INSTRUCTION_EPILOG_(peekl/nR/nR/nR, peekl__nR__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28220 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28221 
28222   JITTER_INSTRUCTION_PROLOG_(peeklu/nR/nR, peeklu__nR__nR, cold)
28223   {
28224     /* This specialized instruction is not a replacement. */
28225 #   undef JITTER_BRANCH_FAST
28226 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28227 #   undef JITTER_BRANCH_FAST_IF_ZERO
28228 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28229 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28230 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28231 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28232 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28233 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28234 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28235 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28236 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28237 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28238 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28239 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28240 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28241 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28242 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28243 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28244 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28245 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28246 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28247 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28248 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28249 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28250 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28251 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28252 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28253 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28254 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28255 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28256 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28257 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28258 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28259 #   undef JITTER_BRANCH_FAST_IF_AND
28260 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28261 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28262 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28263 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28264 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28265 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28266 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28267 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28268 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28269 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28270 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28271 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28272 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28273 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28274 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28275 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28276 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28277 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28278 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28279 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28280 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28281 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28282 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28283 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28284 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28285 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28286 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28287 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28288 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28289 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       194
28290 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peeklu/nR/nR
28291 
28292 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peeklu__nR__nR
28293 
28294   /* The residual arity for this instruction does not depend on fast labels. */
28295   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
28296 
28297     /* The 0th argument is a residual literal. */
28298 #if defined(JITTER_DISPATCH_NO_THREADING)
28299 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28300     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28301 #elif defined (JITTER_REPLICATE)
28302 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28303 #else
28304 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28305 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28306 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28307 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28308 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28309 #   define JITTER_ARGF0 JITTER_ARGP0
28310 
28311     /* The 1th argument is a residual literal. */
28312 #if defined(JITTER_DISPATCH_NO_THREADING)
28313 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
28314     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
28315 #elif defined (JITTER_REPLICATE)
28316 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
28317 #else
28318 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
28319 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28320 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
28321 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
28322 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
28323 #   define JITTER_ARGF1 JITTER_ARGP1
28324 
28325 
28326 #if defined (JITTER_PROFILE_SAMPLE)
28327   JITTER_PROFILE_SAMPLE_UPDATE
28328      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28329       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28330   /* Force the compiler not move sample-profiling instrumentation
28331      beyond this point; this way the actual user code is timed.
28332      This is still not perfect, as residuals are materialised before
28333      we arrive here, but should be adequate at least for slow VM
28334      instructions. */
28335   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28336 #endif
28337 #if defined (JITTER_PROFILE_COUNT)
28338   /* Notice that, differently from the code above, this
28339      instrumentation code *can* be reordered freely: as long as a
28340      VM instruction is counted, the count increment can be placed
28341      anyehere.  Let GCC move this code and possibly achieve better
28342      throughput by exploiting instruction-level parallelism and
28343      therefore approximate more closely a non-profiled build. */
28344   JITTER_PROFILE_COUNT_UPDATE
28345      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28346       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28347 #endif
28348 
28349 /* User-specified code, instruction-beginning-c part: beginning. */
28350 
28351 /* User-specified code, instruction-beginning-c part: end */
28352 
28353 
28354     /* User code for peeklu/nR/nR . */
28355 #line 5301 "../../libpoke/pvm.jitter"
28356 
28357    PVM_PEEK (ulong, uint, 0 /* unused */, JITTER_ARGN0, JITTER_ARGN1,
28358              PVM_IOS_ARGS_UINT);
28359 
28360     /* End of the user code for peeklu/nR/nR . */
28361 
28362 /* User-specified code, instruction-end-c part: beginning. */
28363 
28364 /* User-specified code, instruction-end-c part: end */
28365 
28366     /* Undefine the peeklu/nR/nR argument macros so they can't be used
28367        by mistake in the instruction body coming next. */
28368 #   undef JITTER_SLOW_REGISTER_OFFSET0
28369 #   undef JITTER_ARG0
28370 #   undef JITTER_ARGN0
28371 #   undef JITTER_ARGU0
28372 #   undef JITTER_ARGP0
28373 #   undef JITTER_ARGF0
28374 #   undef JITTER_SLOW_REGISTER_OFFSET1
28375 #   undef JITTER_ARG1
28376 #   undef JITTER_ARGN1
28377 #   undef JITTER_ARGU1
28378 #   undef JITTER_ARGP1
28379 #   undef JITTER_ARGF1
28380 
28381 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28382 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28383 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28384 
28385   }
28386  JITTER_INSTRUCTION_EPILOG_(peeklu/nR/nR, peeklu__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28387 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28388 
28389   JITTER_INSTRUCTION_PROLOG_(peeks, peeks, hot)
28390   {
28391     /* This specialized instruction is not a replacement. */
28392 #   undef JITTER_BRANCH_FAST
28393 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28394 #   undef JITTER_BRANCH_FAST_IF_ZERO
28395 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28396 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28397 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28398 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28399 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28400 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28401 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28402 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28403 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28404 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28405 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28406 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28407 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28408 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28409 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28410 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28411 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28412 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28413 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28414 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28415 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28416 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28417 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28418 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28419 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28420 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28421 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28422 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28423 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28424 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28425 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28426 #   undef JITTER_BRANCH_FAST_IF_AND
28427 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28428 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28429 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28430 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28431 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28432 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28433 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28434 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28435 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28436 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28437 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28438 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28439 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28440 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28441 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28442 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28443 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28444 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28445 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28446 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28447 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28448 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28449 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28450 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28451 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28452 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28453 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28454 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28455 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28456 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       195
28457 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         peeks
28458 
28459 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME peeks
28460 
28461   /* The residual arity for this instruction does not depend on fast labels. */
28462   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28463 
28464 
28465 #if defined (JITTER_PROFILE_SAMPLE)
28466   JITTER_PROFILE_SAMPLE_UPDATE
28467      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28468       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28469   /* Force the compiler not move sample-profiling instrumentation
28470      beyond this point; this way the actual user code is timed.
28471      This is still not perfect, as residuals are materialised before
28472      we arrive here, but should be adequate at least for slow VM
28473      instructions. */
28474   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28475 #endif
28476 #if defined (JITTER_PROFILE_COUNT)
28477   /* Notice that, differently from the code above, this
28478      instrumentation code *can* be reordered freely: as long as a
28479      VM instruction is counted, the count increment can be placed
28480      anyehere.  Let GCC move this code and possibly achieve better
28481      throughput by exploiting instruction-level parallelism and
28482      therefore approximate more closely a non-profiled build. */
28483   JITTER_PROFILE_COUNT_UPDATE
28484      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28485       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28486 #endif
28487 
28488 /* User-specified code, instruction-beginning-c part: beginning. */
28489 
28490 /* User-specified code, instruction-beginning-c part: end */
28491 
28492 
28493     /* User code for peeks . */
28494 #line 5486 "../../libpoke/pvm.jitter"
28495 
28496     ios io;
28497     ios_off offset;
28498     char *ios_str;
28499     int ret;
28500 
28501     offset = PVM_VAL_ULONG (JITTER_TOP_STACK ());
28502     io = ios_search_by_id (PVM_VAL_INT (JITTER_UNDER_TOP_STACK ()));
28503 
28504     if (io == NULL)
28505       PVM_RAISE_DFL (PVM_E_NO_IOS);
28506 
28507     JITTER_DROP_STACK ();
28508     if ((ret = ios_read_string (io, offset, 0 /* flags */, &ios_str)) != IOS_OK)
28509     {
28510       if (ret == IOS_EIOFF)
28511          PVM_RAISE_DFL (PVM_E_EOF);
28512       else if (ret == IOS_ENOMEM)
28513          PVM_RAISE (PVM_E_IO, "out of memory", PVM_E_IO_ESTATUS);
28514       else
28515          PVM_RAISE_DFL (PVM_E_IO);
28516       JITTER_TOP_STACK () = PVM_NULL;
28517     }
28518     else
28519       JITTER_TOP_STACK () = pvm_make_string (ios_str);
28520 
28521     /* End of the user code for peeks . */
28522 
28523 /* User-specified code, instruction-end-c part: beginning. */
28524 
28525 /* User-specified code, instruction-end-c part: end */
28526 
28527     /* Undefine the peeks argument macros so they can't be used
28528        by mistake in the instruction body coming next. */
28529 
28530 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28531 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28532 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28533 
28534   }
28535  JITTER_INSTRUCTION_EPILOG_(peeks, peeks, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28536 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28537 
28538   JITTER_INSTRUCTION_PROLOG_(pokedi/nR, pokedi__nR, cold)
28539   {
28540     /* This specialized instruction is not a replacement. */
28541 #   undef JITTER_BRANCH_FAST
28542 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28543 #   undef JITTER_BRANCH_FAST_IF_ZERO
28544 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28545 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28546 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28547 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28548 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28549 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28550 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28551 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28552 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28553 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28554 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28555 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28556 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28557 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28558 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28559 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28560 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28561 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28562 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28563 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28564 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28565 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28566 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28567 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28568 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28569 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28570 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28571 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28572 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28573 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28574 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28575 #   undef JITTER_BRANCH_FAST_IF_AND
28576 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28577 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28578 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28579 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28580 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28581 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28582 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28583 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28584 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28585 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28586 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28587 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28588 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28589 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28590 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28591 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28592 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28593 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28594 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28595 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28596 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28597 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28598 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28599 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28600 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28601 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28602 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28603 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28604 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28605 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       196
28606 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokedi/nR
28607 
28608 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokedi__nR
28609 
28610   /* The residual arity for this instruction does not depend on fast labels. */
28611   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
28612 
28613     /* The 0th argument is a residual literal. */
28614 #if defined(JITTER_DISPATCH_NO_THREADING)
28615 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28616     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28617 #elif defined (JITTER_REPLICATE)
28618 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28619 #else
28620 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28621 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28622 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28623 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28624 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28625 #   define JITTER_ARGF0 JITTER_ARGP0
28626 
28627 
28628 #if defined (JITTER_PROFILE_SAMPLE)
28629   JITTER_PROFILE_SAMPLE_UPDATE
28630      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28631       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28632   /* Force the compiler not move sample-profiling instrumentation
28633      beyond this point; this way the actual user code is timed.
28634      This is still not perfect, as residuals are materialised before
28635      we arrive here, but should be adequate at least for slow VM
28636      instructions. */
28637   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28638 #endif
28639 #if defined (JITTER_PROFILE_COUNT)
28640   /* Notice that, differently from the code above, this
28641      instrumentation code *can* be reordered freely: as long as a
28642      VM instruction is counted, the count increment can be placed
28643      anyehere.  Let GCC move this code and possibly achieve better
28644      throughput by exploiting instruction-level parallelism and
28645      therefore approximate more closely a non-profiled build. */
28646   JITTER_PROFILE_COUNT_UPDATE
28647      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28648       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28649 #endif
28650 
28651 /* User-specified code, instruction-beginning-c part: beginning. */
28652 
28653 /* User-specified code, instruction-beginning-c part: end */
28654 
28655 
28656     /* User code for pokedi/nR . */
28657 #line 5431 "../../libpoke/pvm.jitter"
28658 
28659     PVM_POKE (INT, int, jitter_state_runtime.nenc, jitter_state_runtime.endian,
28660               JITTER_ARGN0, PVM_IOS_ARGS_WRITE_INT);
28661 
28662     /* End of the user code for pokedi/nR . */
28663 
28664 /* User-specified code, instruction-end-c part: beginning. */
28665 
28666 /* User-specified code, instruction-end-c part: end */
28667 
28668     /* Undefine the pokedi/nR argument macros so they can't be used
28669        by mistake in the instruction body coming next. */
28670 #   undef JITTER_SLOW_REGISTER_OFFSET0
28671 #   undef JITTER_ARG0
28672 #   undef JITTER_ARGN0
28673 #   undef JITTER_ARGU0
28674 #   undef JITTER_ARGP0
28675 #   undef JITTER_ARGF0
28676 
28677 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28678 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28679 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28680 
28681   }
28682  JITTER_INSTRUCTION_EPILOG_(pokedi/nR, pokedi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28683 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28684 
28685   JITTER_INSTRUCTION_PROLOG_(pokediu/nR, pokediu__nR, cold)
28686   {
28687     /* This specialized instruction is not a replacement. */
28688 #   undef JITTER_BRANCH_FAST
28689 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28690 #   undef JITTER_BRANCH_FAST_IF_ZERO
28691 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28692 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28693 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28694 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28695 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28696 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28697 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28698 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28699 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28700 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28701 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28702 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28703 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28704 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28705 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28706 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28707 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28708 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28709 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28710 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28711 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28712 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28713 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28714 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28715 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28716 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28717 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28718 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28719 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28720 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28721 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28722 #   undef JITTER_BRANCH_FAST_IF_AND
28723 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28724 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28725 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28726 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28727 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28728 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28729 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28730 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28731 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28732 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28733 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28734 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28735 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28736 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28737 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28738 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28739 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28740 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28741 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28742 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28743 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28744 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28745 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28746 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28747 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28748 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28749 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28750 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28751 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28752 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       197
28753 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokediu/nR
28754 
28755 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokediu__nR
28756 
28757   /* The residual arity for this instruction does not depend on fast labels. */
28758   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
28759 
28760     /* The 0th argument is a residual literal. */
28761 #if defined(JITTER_DISPATCH_NO_THREADING)
28762 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28763     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28764 #elif defined (JITTER_REPLICATE)
28765 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28766 #else
28767 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28768 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28769 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28770 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28771 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28772 #   define JITTER_ARGF0 JITTER_ARGP0
28773 
28774 
28775 #if defined (JITTER_PROFILE_SAMPLE)
28776   JITTER_PROFILE_SAMPLE_UPDATE
28777      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28778       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28779   /* Force the compiler not move sample-profiling instrumentation
28780      beyond this point; this way the actual user code is timed.
28781      This is still not perfect, as residuals are materialised before
28782      we arrive here, but should be adequate at least for slow VM
28783      instructions. */
28784   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28785 #endif
28786 #if defined (JITTER_PROFILE_COUNT)
28787   /* Notice that, differently from the code above, this
28788      instrumentation code *can* be reordered freely: as long as a
28789      VM instruction is counted, the count increment can be placed
28790      anyehere.  Let GCC move this code and possibly achieve better
28791      throughput by exploiting instruction-level parallelism and
28792      therefore approximate more closely a non-profiled build. */
28793   JITTER_PROFILE_COUNT_UPDATE
28794      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28795       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28796 #endif
28797 
28798 /* User-specified code, instruction-beginning-c part: beginning. */
28799 
28800 /* User-specified code, instruction-beginning-c part: end */
28801 
28802 
28803     /* User code for pokediu/nR . */
28804 #line 5445 "../../libpoke/pvm.jitter"
28805 
28806     PVM_POKE (UINT, uint, jitter_state_runtime.nenc, jitter_state_runtime.endian,
28807               JITTER_ARGN0, PVM_IOS_ARGS_WRITE_UINT);
28808 
28809     /* End of the user code for pokediu/nR . */
28810 
28811 /* User-specified code, instruction-end-c part: beginning. */
28812 
28813 /* User-specified code, instruction-end-c part: end */
28814 
28815     /* Undefine the pokediu/nR argument macros so they can't be used
28816        by mistake in the instruction body coming next. */
28817 #   undef JITTER_SLOW_REGISTER_OFFSET0
28818 #   undef JITTER_ARG0
28819 #   undef JITTER_ARGN0
28820 #   undef JITTER_ARGU0
28821 #   undef JITTER_ARGP0
28822 #   undef JITTER_ARGF0
28823 
28824 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28825 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28826 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28827 
28828   }
28829  JITTER_INSTRUCTION_EPILOG_(pokediu/nR, pokediu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28830 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28831 
28832   JITTER_INSTRUCTION_PROLOG_(pokedl/nR, pokedl__nR, cold)
28833   {
28834     /* This specialized instruction is not a replacement. */
28835 #   undef JITTER_BRANCH_FAST
28836 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28837 #   undef JITTER_BRANCH_FAST_IF_ZERO
28838 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28839 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28840 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28841 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28842 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28843 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28844 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28845 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28846 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28847 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28848 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28849 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28850 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28851 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28852 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28853 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28854 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28855 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28856 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28857 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28858 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28859 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28860 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28861 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28862 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28863 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28864 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28865 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28866 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28867 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28868 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28869 #   undef JITTER_BRANCH_FAST_IF_AND
28870 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28871 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28872 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28873 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28874 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28875 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28876 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28877 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28878 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28879 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28880 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28881 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28882 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28883 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28884 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28885 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28886 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28887 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28888 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28889 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28890 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28891 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28892 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28893 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28894 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28895 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28896 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28897 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28898 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28899 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       198
28900 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokedl/nR
28901 
28902 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokedl__nR
28903 
28904   /* The residual arity for this instruction does not depend on fast labels. */
28905   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
28906 
28907     /* The 0th argument is a residual literal. */
28908 #if defined(JITTER_DISPATCH_NO_THREADING)
28909 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28910     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28911 #elif defined (JITTER_REPLICATE)
28912 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28913 #else
28914 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28915 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28916 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28917 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28918 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28919 #   define JITTER_ARGF0 JITTER_ARGP0
28920 
28921 
28922 #if defined (JITTER_PROFILE_SAMPLE)
28923   JITTER_PROFILE_SAMPLE_UPDATE
28924      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28925       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28926   /* Force the compiler not move sample-profiling instrumentation
28927      beyond this point; this way the actual user code is timed.
28928      This is still not perfect, as residuals are materialised before
28929      we arrive here, but should be adequate at least for slow VM
28930      instructions. */
28931   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28932 #endif
28933 #if defined (JITTER_PROFILE_COUNT)
28934   /* Notice that, differently from the code above, this
28935      instrumentation code *can* be reordered freely: as long as a
28936      VM instruction is counted, the count increment can be placed
28937      anyehere.  Let GCC move this code and possibly achieve better
28938      throughput by exploiting instruction-level parallelism and
28939      therefore approximate more closely a non-profiled build. */
28940   JITTER_PROFILE_COUNT_UPDATE
28941      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28942       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28943 #endif
28944 
28945 /* User-specified code, instruction-beginning-c part: beginning. */
28946 
28947 /* User-specified code, instruction-beginning-c part: end */
28948 
28949 
28950     /* User code for pokedl/nR . */
28951 #line 5459 "../../libpoke/pvm.jitter"
28952 
28953     PVM_POKE (LONG, int, jitter_state_runtime.nenc, jitter_state_runtime.endian,
28954               JITTER_ARGN0, PVM_IOS_ARGS_WRITE_INT);
28955 
28956     /* End of the user code for pokedl/nR . */
28957 
28958 /* User-specified code, instruction-end-c part: beginning. */
28959 
28960 /* User-specified code, instruction-end-c part: end */
28961 
28962     /* Undefine the pokedl/nR argument macros so they can't be used
28963        by mistake in the instruction body coming next. */
28964 #   undef JITTER_SLOW_REGISTER_OFFSET0
28965 #   undef JITTER_ARG0
28966 #   undef JITTER_ARGN0
28967 #   undef JITTER_ARGU0
28968 #   undef JITTER_ARGP0
28969 #   undef JITTER_ARGF0
28970 
28971 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28972 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28973 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28974 
28975   }
28976  JITTER_INSTRUCTION_EPILOG_(pokedl/nR, pokedl__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28977 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28978 
28979   JITTER_INSTRUCTION_PROLOG_(pokedlu/nR, pokedlu__nR, cold)
28980   {
28981     /* This specialized instruction is not a replacement. */
28982 #   undef JITTER_BRANCH_FAST
28983 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28984 #   undef JITTER_BRANCH_FAST_IF_ZERO
28985 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28986 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28987 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28988 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28989 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28990 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28991 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28992 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28993 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28994 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28995 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28996 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28997 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28998 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28999 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29000 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29001 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29002 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29003 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29004 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29005 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29006 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29007 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29008 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29009 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29010 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29011 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29012 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29013 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29014 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29015 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29016 #   undef JITTER_BRANCH_FAST_IF_AND
29017 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29018 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29019 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29020 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29021 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29022 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29023 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29024 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29025 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29026 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29027 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29028 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29029 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29030 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29031 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29032 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29033 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29034 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29035 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29036 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29037 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29038 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29039 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29040 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29041 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29042 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29043 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29044 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29045 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29046 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       199
29047 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokedlu/nR
29048 
29049 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokedlu__nR
29050 
29051   /* The residual arity for this instruction does not depend on fast labels. */
29052   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
29053 
29054     /* The 0th argument is a residual literal. */
29055 #if defined(JITTER_DISPATCH_NO_THREADING)
29056 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29057     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29058 #elif defined (JITTER_REPLICATE)
29059 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29060 #else
29061 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29062 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29063 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29064 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29065 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29066 #   define JITTER_ARGF0 JITTER_ARGP0
29067 
29068 
29069 #if defined (JITTER_PROFILE_SAMPLE)
29070   JITTER_PROFILE_SAMPLE_UPDATE
29071      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29072       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29073   /* Force the compiler not move sample-profiling instrumentation
29074      beyond this point; this way the actual user code is timed.
29075      This is still not perfect, as residuals are materialised before
29076      we arrive here, but should be adequate at least for slow VM
29077      instructions. */
29078   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29079 #endif
29080 #if defined (JITTER_PROFILE_COUNT)
29081   /* Notice that, differently from the code above, this
29082      instrumentation code *can* be reordered freely: as long as a
29083      VM instruction is counted, the count increment can be placed
29084      anyehere.  Let GCC move this code and possibly achieve better
29085      throughput by exploiting instruction-level parallelism and
29086      therefore approximate more closely a non-profiled build. */
29087   JITTER_PROFILE_COUNT_UPDATE
29088      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29089       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29090 #endif
29091 
29092 /* User-specified code, instruction-beginning-c part: beginning. */
29093 
29094 /* User-specified code, instruction-beginning-c part: end */
29095 
29096 
29097     /* User code for pokedlu/nR . */
29098 #line 5473 "../../libpoke/pvm.jitter"
29099 
29100     PVM_POKE (ULONG, uint, jitter_state_runtime.nenc, jitter_state_runtime.endian,
29101               JITTER_ARGN0, PVM_IOS_ARGS_WRITE_UINT);
29102 
29103     /* End of the user code for pokedlu/nR . */
29104 
29105 /* User-specified code, instruction-end-c part: beginning. */
29106 
29107 /* User-specified code, instruction-end-c part: end */
29108 
29109     /* Undefine the pokedlu/nR argument macros so they can't be used
29110        by mistake in the instruction body coming next. */
29111 #   undef JITTER_SLOW_REGISTER_OFFSET0
29112 #   undef JITTER_ARG0
29113 #   undef JITTER_ARGN0
29114 #   undef JITTER_ARGU0
29115 #   undef JITTER_ARGP0
29116 #   undef JITTER_ARGF0
29117 
29118 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29119 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29120 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29121 
29122   }
29123  JITTER_INSTRUCTION_EPILOG_(pokedlu/nR, pokedlu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29124 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29125 
29126   JITTER_INSTRUCTION_PROLOG_(pokei/nR/nR/nR, pokei__nR__nR__nR, cold)
29127   {
29128     /* This specialized instruction is not a replacement. */
29129 #   undef JITTER_BRANCH_FAST
29130 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29131 #   undef JITTER_BRANCH_FAST_IF_ZERO
29132 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29133 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29134 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29135 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29136 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29137 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29138 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29139 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29140 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29141 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29142 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29143 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29144 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29145 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29146 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29147 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29148 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29149 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29150 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29151 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29152 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29153 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29154 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29155 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29156 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29157 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29158 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29159 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29160 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29161 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29162 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29163 #   undef JITTER_BRANCH_FAST_IF_AND
29164 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29165 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29166 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29167 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29168 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29169 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29170 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29171 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29172 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29173 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29174 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29175 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29176 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29177 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29178 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29179 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29180 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29181 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29182 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29183 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29184 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29185 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29186 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29187 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29188 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29189 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29190 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29191 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29192 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29193 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       200
29194 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokei/nR/nR/nR
29195 
29196 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokei__nR__nR__nR
29197 
29198   /* The residual arity for this instruction does not depend on fast labels. */
29199   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
29200 
29201     /* The 0th argument is a residual literal. */
29202 #if defined(JITTER_DISPATCH_NO_THREADING)
29203 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29204     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29205 #elif defined (JITTER_REPLICATE)
29206 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29207 #else
29208 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29209 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29210 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29211 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29212 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29213 #   define JITTER_ARGF0 JITTER_ARGP0
29214 
29215     /* The 1th argument is a residual literal. */
29216 #if defined(JITTER_DISPATCH_NO_THREADING)
29217 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
29218     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
29219 #elif defined (JITTER_REPLICATE)
29220 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
29221 #else
29222 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
29223 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29224 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
29225 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
29226 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
29227 #   define JITTER_ARGF1 JITTER_ARGP1
29228 
29229     /* The 2th argument is a residual literal. */
29230 #if defined(JITTER_DISPATCH_NO_THREADING)
29231 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
29232     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
29233 #elif defined (JITTER_REPLICATE)
29234 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
29235 #else
29236 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
29237 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29238 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
29239 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
29240 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
29241 #   define JITTER_ARGF2 JITTER_ARGP2
29242 
29243 
29244 #if defined (JITTER_PROFILE_SAMPLE)
29245   JITTER_PROFILE_SAMPLE_UPDATE
29246      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29247       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29248   /* Force the compiler not move sample-profiling instrumentation
29249      beyond this point; this way the actual user code is timed.
29250      This is still not perfect, as residuals are materialised before
29251      we arrive here, but should be adequate at least for slow VM
29252      instructions. */
29253   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29254 #endif
29255 #if defined (JITTER_PROFILE_COUNT)
29256   /* Notice that, differently from the code above, this
29257      instrumentation code *can* be reordered freely: as long as a
29258      VM instruction is counted, the count increment can be placed
29259      anyehere.  Let GCC move this code and possibly achieve better
29260      throughput by exploiting instruction-level parallelism and
29261      therefore approximate more closely a non-profiled build. */
29262   JITTER_PROFILE_COUNT_UPDATE
29263      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29264       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29265 #endif
29266 
29267 /* User-specified code, instruction-beginning-c part: beginning. */
29268 
29269 /* User-specified code, instruction-beginning-c part: end */
29270 
29271 
29272     /* User code for pokei/nR/nR/nR . */
29273 #line 5372 "../../libpoke/pvm.jitter"
29274 
29275     PVM_POKE (INT, int, JITTER_ARGN0, JITTER_ARGN1, JITTER_ARGN2,
29276               PVM_IOS_ARGS_WRITE_INT);
29277 
29278     /* End of the user code for pokei/nR/nR/nR . */
29279 
29280 /* User-specified code, instruction-end-c part: beginning. */
29281 
29282 /* User-specified code, instruction-end-c part: end */
29283 
29284     /* Undefine the pokei/nR/nR/nR argument macros so they can't be used
29285        by mistake in the instruction body coming next. */
29286 #   undef JITTER_SLOW_REGISTER_OFFSET0
29287 #   undef JITTER_ARG0
29288 #   undef JITTER_ARGN0
29289 #   undef JITTER_ARGU0
29290 #   undef JITTER_ARGP0
29291 #   undef JITTER_ARGF0
29292 #   undef JITTER_SLOW_REGISTER_OFFSET1
29293 #   undef JITTER_ARG1
29294 #   undef JITTER_ARGN1
29295 #   undef JITTER_ARGU1
29296 #   undef JITTER_ARGP1
29297 #   undef JITTER_ARGF1
29298 #   undef JITTER_SLOW_REGISTER_OFFSET2
29299 #   undef JITTER_ARG2
29300 #   undef JITTER_ARGN2
29301 #   undef JITTER_ARGU2
29302 #   undef JITTER_ARGP2
29303 #   undef JITTER_ARGF2
29304 
29305 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29306 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29307 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29308 
29309   }
29310  JITTER_INSTRUCTION_EPILOG_(pokei/nR/nR/nR, pokei__nR__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29311 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29312 
29313   JITTER_INSTRUCTION_PROLOG_(pokeiu/nR/nR, pokeiu__nR__nR, cold)
29314   {
29315     /* This specialized instruction is not a replacement. */
29316 #   undef JITTER_BRANCH_FAST
29317 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29318 #   undef JITTER_BRANCH_FAST_IF_ZERO
29319 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29320 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29321 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29322 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29323 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29324 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29325 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29326 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29327 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29328 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29329 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29330 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29331 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29332 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29333 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29334 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29335 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29336 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29337 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29338 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29339 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29340 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29341 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29342 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29343 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29344 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29345 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29346 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29347 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29348 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29349 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29350 #   undef JITTER_BRANCH_FAST_IF_AND
29351 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29352 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29353 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29354 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29355 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29356 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29357 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29358 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29359 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29360 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29361 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29362 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29363 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29364 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29365 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29366 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29367 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29368 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29369 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29370 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29371 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29372 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29373 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29374 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29375 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29376 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29377 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29378 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29379 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29380 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       201
29381 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokeiu/nR/nR
29382 
29383 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokeiu__nR__nR
29384 
29385   /* The residual arity for this instruction does not depend on fast labels. */
29386   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
29387 
29388     /* The 0th argument is a residual literal. */
29389 #if defined(JITTER_DISPATCH_NO_THREADING)
29390 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29391     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29392 #elif defined (JITTER_REPLICATE)
29393 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29394 #else
29395 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29396 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29397 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29398 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29399 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29400 #   define JITTER_ARGF0 JITTER_ARGP0
29401 
29402     /* The 1th argument is a residual literal. */
29403 #if defined(JITTER_DISPATCH_NO_THREADING)
29404 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
29405     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
29406 #elif defined (JITTER_REPLICATE)
29407 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
29408 #else
29409 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
29410 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29411 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
29412 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
29413 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
29414 #   define JITTER_ARGF1 JITTER_ARGP1
29415 
29416 
29417 #if defined (JITTER_PROFILE_SAMPLE)
29418   JITTER_PROFILE_SAMPLE_UPDATE
29419      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29420       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29421   /* Force the compiler not move sample-profiling instrumentation
29422      beyond this point; this way the actual user code is timed.
29423      This is still not perfect, as residuals are materialised before
29424      we arrive here, but should be adequate at least for slow VM
29425      instructions. */
29426   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29427 #endif
29428 #if defined (JITTER_PROFILE_COUNT)
29429   /* Notice that, differently from the code above, this
29430      instrumentation code *can* be reordered freely: as long as a
29431      VM instruction is counted, the count increment can be placed
29432      anyehere.  Let GCC move this code and possibly achieve better
29433      throughput by exploiting instruction-level parallelism and
29434      therefore approximate more closely a non-profiled build. */
29435   JITTER_PROFILE_COUNT_UPDATE
29436      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29437       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29438 #endif
29439 
29440 /* User-specified code, instruction-beginning-c part: beginning. */
29441 
29442 /* User-specified code, instruction-beginning-c part: end */
29443 
29444 
29445     /* User code for pokeiu/nR/nR . */
29446 #line 5387 "../../libpoke/pvm.jitter"
29447 
29448    PVM_POKE (UINT, uint, 0 /* unused */, JITTER_ARGN0, JITTER_ARGN1,
29449              PVM_IOS_ARGS_WRITE_UINT);
29450 
29451     /* End of the user code for pokeiu/nR/nR . */
29452 
29453 /* User-specified code, instruction-end-c part: beginning. */
29454 
29455 /* User-specified code, instruction-end-c part: end */
29456 
29457     /* Undefine the pokeiu/nR/nR argument macros so they can't be used
29458        by mistake in the instruction body coming next. */
29459 #   undef JITTER_SLOW_REGISTER_OFFSET0
29460 #   undef JITTER_ARG0
29461 #   undef JITTER_ARGN0
29462 #   undef JITTER_ARGU0
29463 #   undef JITTER_ARGP0
29464 #   undef JITTER_ARGF0
29465 #   undef JITTER_SLOW_REGISTER_OFFSET1
29466 #   undef JITTER_ARG1
29467 #   undef JITTER_ARGN1
29468 #   undef JITTER_ARGU1
29469 #   undef JITTER_ARGP1
29470 #   undef JITTER_ARGF1
29471 
29472 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29473 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29474 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29475 
29476   }
29477  JITTER_INSTRUCTION_EPILOG_(pokeiu/nR/nR, pokeiu__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29478 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29479 
29480   JITTER_INSTRUCTION_PROLOG_(pokel/nR/nR/nR, pokel__nR__nR__nR, cold)
29481   {
29482     /* This specialized instruction is not a replacement. */
29483 #   undef JITTER_BRANCH_FAST
29484 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29485 #   undef JITTER_BRANCH_FAST_IF_ZERO
29486 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29487 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29488 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29489 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29490 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29491 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29492 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29493 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29494 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29495 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29496 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29497 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29498 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29499 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29500 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29501 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29502 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29503 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29504 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29505 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29506 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29507 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29508 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29509 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29510 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29511 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29512 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29513 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29514 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29515 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29516 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29517 #   undef JITTER_BRANCH_FAST_IF_AND
29518 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29519 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29520 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29521 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29522 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29523 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29524 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29525 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29526 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29527 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29528 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29529 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29530 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29531 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29532 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29533 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29534 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29535 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29536 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29537 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29538 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29539 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29540 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29541 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29542 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29543 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29544 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29545 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29546 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29547 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       202
29548 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokel/nR/nR/nR
29549 
29550 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokel__nR__nR__nR
29551 
29552   /* The residual arity for this instruction does not depend on fast labels. */
29553   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
29554 
29555     /* The 0th argument is a residual literal. */
29556 #if defined(JITTER_DISPATCH_NO_THREADING)
29557 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29558     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29559 #elif defined (JITTER_REPLICATE)
29560 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29561 #else
29562 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29563 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29564 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29565 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29566 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29567 #   define JITTER_ARGF0 JITTER_ARGP0
29568 
29569     /* The 1th argument is a residual literal. */
29570 #if defined(JITTER_DISPATCH_NO_THREADING)
29571 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
29572     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
29573 #elif defined (JITTER_REPLICATE)
29574 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
29575 #else
29576 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
29577 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29578 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
29579 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
29580 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
29581 #   define JITTER_ARGF1 JITTER_ARGP1
29582 
29583     /* The 2th argument is a residual literal. */
29584 #if defined(JITTER_DISPATCH_NO_THREADING)
29585 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
29586     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
29587 #elif defined (JITTER_REPLICATE)
29588 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
29589 #else
29590 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
29591 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29592 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
29593 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
29594 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
29595 #   define JITTER_ARGF2 JITTER_ARGP2
29596 
29597 
29598 #if defined (JITTER_PROFILE_SAMPLE)
29599   JITTER_PROFILE_SAMPLE_UPDATE
29600      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29601       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29602   /* Force the compiler not move sample-profiling instrumentation
29603      beyond this point; this way the actual user code is timed.
29604      This is still not perfect, as residuals are materialised before
29605      we arrive here, but should be adequate at least for slow VM
29606      instructions. */
29607   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29608 #endif
29609 #if defined (JITTER_PROFILE_COUNT)
29610   /* Notice that, differently from the code above, this
29611      instrumentation code *can* be reordered freely: as long as a
29612      VM instruction is counted, the count increment can be placed
29613      anyehere.  Let GCC move this code and possibly achieve better
29614      throughput by exploiting instruction-level parallelism and
29615      therefore approximate more closely a non-profiled build. */
29616   JITTER_PROFILE_COUNT_UPDATE
29617      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29618       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29619 #endif
29620 
29621 /* User-specified code, instruction-beginning-c part: beginning. */
29622 
29623 /* User-specified code, instruction-beginning-c part: end */
29624 
29625 
29626     /* User code for pokel/nR/nR/nR . */
29627 #line 5402 "../../libpoke/pvm.jitter"
29628 
29629     PVM_POKE (LONG, int, JITTER_ARGN0, JITTER_ARGN1, JITTER_ARGN2,
29630               PVM_IOS_ARGS_WRITE_INT);
29631 
29632     /* End of the user code for pokel/nR/nR/nR . */
29633 
29634 /* User-specified code, instruction-end-c part: beginning. */
29635 
29636 /* User-specified code, instruction-end-c part: end */
29637 
29638     /* Undefine the pokel/nR/nR/nR argument macros so they can't be used
29639        by mistake in the instruction body coming next. */
29640 #   undef JITTER_SLOW_REGISTER_OFFSET0
29641 #   undef JITTER_ARG0
29642 #   undef JITTER_ARGN0
29643 #   undef JITTER_ARGU0
29644 #   undef JITTER_ARGP0
29645 #   undef JITTER_ARGF0
29646 #   undef JITTER_SLOW_REGISTER_OFFSET1
29647 #   undef JITTER_ARG1
29648 #   undef JITTER_ARGN1
29649 #   undef JITTER_ARGU1
29650 #   undef JITTER_ARGP1
29651 #   undef JITTER_ARGF1
29652 #   undef JITTER_SLOW_REGISTER_OFFSET2
29653 #   undef JITTER_ARG2
29654 #   undef JITTER_ARGN2
29655 #   undef JITTER_ARGU2
29656 #   undef JITTER_ARGP2
29657 #   undef JITTER_ARGF2
29658 
29659 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29660 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29661 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29662 
29663   }
29664  JITTER_INSTRUCTION_EPILOG_(pokel/nR/nR/nR, pokel__nR__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29665 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29666 
29667   JITTER_INSTRUCTION_PROLOG_(pokelu/nR/nR, pokelu__nR__nR, cold)
29668   {
29669     /* This specialized instruction is not a replacement. */
29670 #   undef JITTER_BRANCH_FAST
29671 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29672 #   undef JITTER_BRANCH_FAST_IF_ZERO
29673 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29674 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29675 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29676 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29677 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29678 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29679 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29680 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29681 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29682 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29683 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29684 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29685 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29686 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29687 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29688 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29689 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29690 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29691 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29692 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29693 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29694 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29695 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29696 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29697 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29698 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29699 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29700 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29701 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29702 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29703 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29704 #   undef JITTER_BRANCH_FAST_IF_AND
29705 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29706 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29707 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29708 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29709 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29710 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29711 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29712 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29713 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29714 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29715 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29716 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29717 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29718 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29719 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29720 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29721 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29722 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29723 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29724 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29725 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29726 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29727 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29728 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29729 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29730 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29731 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29732 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29733 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29734 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       203
29735 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokelu/nR/nR
29736 
29737 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokelu__nR__nR
29738 
29739   /* The residual arity for this instruction does not depend on fast labels. */
29740   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
29741 
29742     /* The 0th argument is a residual literal. */
29743 #if defined(JITTER_DISPATCH_NO_THREADING)
29744 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29745     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29746 #elif defined (JITTER_REPLICATE)
29747 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29748 #else
29749 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29750 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29751 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29752 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29753 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29754 #   define JITTER_ARGF0 JITTER_ARGP0
29755 
29756     /* The 1th argument is a residual literal. */
29757 #if defined(JITTER_DISPATCH_NO_THREADING)
29758 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
29759     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
29760 #elif defined (JITTER_REPLICATE)
29761 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
29762 #else
29763 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
29764 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29765 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
29766 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
29767 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
29768 #   define JITTER_ARGF1 JITTER_ARGP1
29769 
29770 
29771 #if defined (JITTER_PROFILE_SAMPLE)
29772   JITTER_PROFILE_SAMPLE_UPDATE
29773      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29774       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29775   /* Force the compiler not move sample-profiling instrumentation
29776      beyond this point; this way the actual user code is timed.
29777      This is still not perfect, as residuals are materialised before
29778      we arrive here, but should be adequate at least for slow VM
29779      instructions. */
29780   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29781 #endif
29782 #if defined (JITTER_PROFILE_COUNT)
29783   /* Notice that, differently from the code above, this
29784      instrumentation code *can* be reordered freely: as long as a
29785      VM instruction is counted, the count increment can be placed
29786      anyehere.  Let GCC move this code and possibly achieve better
29787      throughput by exploiting instruction-level parallelism and
29788      therefore approximate more closely a non-profiled build. */
29789   JITTER_PROFILE_COUNT_UPDATE
29790      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29791       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29792 #endif
29793 
29794 /* User-specified code, instruction-beginning-c part: beginning. */
29795 
29796 /* User-specified code, instruction-beginning-c part: end */
29797 
29798 
29799     /* User code for pokelu/nR/nR . */
29800 #line 5417 "../../libpoke/pvm.jitter"
29801 
29802    PVM_POKE (ULONG, uint, 0 /* unused */, JITTER_ARGN0, JITTER_ARGN1,
29803              PVM_IOS_ARGS_WRITE_UINT);
29804 
29805     /* End of the user code for pokelu/nR/nR . */
29806 
29807 /* User-specified code, instruction-end-c part: beginning. */
29808 
29809 /* User-specified code, instruction-end-c part: end */
29810 
29811     /* Undefine the pokelu/nR/nR argument macros so they can't be used
29812        by mistake in the instruction body coming next. */
29813 #   undef JITTER_SLOW_REGISTER_OFFSET0
29814 #   undef JITTER_ARG0
29815 #   undef JITTER_ARGN0
29816 #   undef JITTER_ARGU0
29817 #   undef JITTER_ARGP0
29818 #   undef JITTER_ARGF0
29819 #   undef JITTER_SLOW_REGISTER_OFFSET1
29820 #   undef JITTER_ARG1
29821 #   undef JITTER_ARGN1
29822 #   undef JITTER_ARGU1
29823 #   undef JITTER_ARGP1
29824 #   undef JITTER_ARGF1
29825 
29826 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29827 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29828 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29829 
29830   }
29831  JITTER_INSTRUCTION_EPILOG_(pokelu/nR/nR, pokelu__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29832 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29833 
29834   JITTER_INSTRUCTION_PROLOG_(pokes, pokes, hot)
29835   {
29836     /* This specialized instruction is not a replacement. */
29837 #   undef JITTER_BRANCH_FAST
29838 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29839 #   undef JITTER_BRANCH_FAST_IF_ZERO
29840 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29841 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29842 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29843 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29844 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29845 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29846 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29847 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29848 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29849 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29850 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29851 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29852 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29853 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29854 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29855 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29856 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29857 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29858 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29859 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29860 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29861 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29862 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29863 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29864 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29865 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29866 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29867 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29868 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29869 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29870 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29871 #   undef JITTER_BRANCH_FAST_IF_AND
29872 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29873 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29874 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29875 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29876 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29877 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29878 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29879 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29880 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29881 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29882 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29883 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29884 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29885 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29886 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29887 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29888 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29889 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29890 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29891 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29892 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29893 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29894 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29895 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29896 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29897 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29898 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29899 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29900 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29901 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       204
29902 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pokes
29903 
29904 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pokes
29905 
29906   /* The residual arity for this instruction does not depend on fast labels. */
29907   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
29908 
29909 
29910 #if defined (JITTER_PROFILE_SAMPLE)
29911   JITTER_PROFILE_SAMPLE_UPDATE
29912      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29913       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29914   /* Force the compiler not move sample-profiling instrumentation
29915      beyond this point; this way the actual user code is timed.
29916      This is still not perfect, as residuals are materialised before
29917      we arrive here, but should be adequate at least for slow VM
29918      instructions. */
29919   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29920 #endif
29921 #if defined (JITTER_PROFILE_COUNT)
29922   /* Notice that, differently from the code above, this
29923      instrumentation code *can* be reordered freely: as long as a
29924      VM instruction is counted, the count increment can be placed
29925      anyehere.  Let GCC move this code and possibly achieve better
29926      throughput by exploiting instruction-level parallelism and
29927      therefore approximate more closely a non-profiled build. */
29928   JITTER_PROFILE_COUNT_UPDATE
29929      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29930       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29931 #endif
29932 
29933 /* User-specified code, instruction-beginning-c part: beginning. */
29934 
29935 /* User-specified code, instruction-beginning-c part: end */
29936 
29937 
29938     /* User code for pokes . */
29939 #line 5521 "../../libpoke/pvm.jitter"
29940 
29941     ios io;
29942     ios_off offset;
29943     char *str;
29944     int ret;
29945 
29946     str = PVM_VAL_STR (JITTER_TOP_STACK ());
29947     offset = PVM_VAL_ULONG (JITTER_UNDER_TOP_STACK ());
29948     JITTER_DROP_STACK();
29949     JITTER_DROP_STACK();
29950 
29951     io = ios_search_by_id (PVM_VAL_INT (JITTER_TOP_STACK ()));
29952 
29953     if (io == NULL)
29954       PVM_RAISE_DFL (PVM_E_NO_IOS);
29955 
29956     JITTER_DROP_STACK ();
29957     if ((ret = ios_write_string (io, offset, 0 /* flags */, str)) != IOS_OK)
29958     {
29959       if (ret == IOS_EIOFF)
29960          PVM_RAISE_DFL (PVM_E_EOF);
29961       else
29962          PVM_RAISE_DFL (PVM_E_IO);
29963     }
29964 
29965     /* End of the user code for pokes . */
29966 
29967 /* User-specified code, instruction-end-c part: beginning. */
29968 
29969 /* User-specified code, instruction-end-c part: end */
29970 
29971     /* Undefine the pokes argument macros so they can't be used
29972        by mistake in the instruction body coming next. */
29973 
29974 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29975 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29976 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29977 
29978   }
29979  JITTER_INSTRUCTION_EPILOG_(pokes, pokes, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29980 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29981 
29982   JITTER_INSTRUCTION_PROLOG_(pope, pope, hot)
29983   {
29984     /* This specialized instruction is not a replacement. */
29985 #   undef JITTER_BRANCH_FAST
29986 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29987 #   undef JITTER_BRANCH_FAST_IF_ZERO
29988 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29989 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29990 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29991 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29992 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29993 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29994 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29995 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29996 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29997 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29998 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29999 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30000 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30001 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30002 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30003 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30004 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30005 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30006 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30007 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30008 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30009 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30010 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30011 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30012 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30013 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30014 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30015 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30016 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30017 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30018 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30019 #   undef JITTER_BRANCH_FAST_IF_AND
30020 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30021 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30022 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30023 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30024 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30025 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30026 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30027 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30028 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30029 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30030 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30031 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30032 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30033 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30034 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30035 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30036 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30037 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30038 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30039 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30040 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30041 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30042 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30043 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30044 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30045 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30046 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30047 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30048 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30049 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       205
30050 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pope
30051 
30052 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pope
30053 
30054   /* The residual arity for this instruction does not depend on fast labels. */
30055   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30056 
30057 
30058 #if defined (JITTER_PROFILE_SAMPLE)
30059   JITTER_PROFILE_SAMPLE_UPDATE
30060      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30061       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30062   /* Force the compiler not move sample-profiling instrumentation
30063      beyond this point; this way the actual user code is timed.
30064      This is still not perfect, as residuals are materialised before
30065      we arrive here, but should be adequate at least for slow VM
30066      instructions. */
30067   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30068 #endif
30069 #if defined (JITTER_PROFILE_COUNT)
30070   /* Notice that, differently from the code above, this
30071      instrumentation code *can* be reordered freely: as long as a
30072      VM instruction is counted, the count increment can be placed
30073      anyehere.  Let GCC move this code and possibly achieve better
30074      throughput by exploiting instruction-level parallelism and
30075      therefore approximate more closely a non-profiled build. */
30076   JITTER_PROFILE_COUNT_UPDATE
30077      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30078       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30079 #endif
30080 
30081 /* User-specified code, instruction-beginning-c part: beginning. */
30082 
30083 /* User-specified code, instruction-beginning-c part: end */
30084 
30085 
30086     /* User code for pope . */
30087 #line 5583 "../../libpoke/pvm.jitter"
30088 
30089     JITTER_DROP_EXCEPTIONSTACK ();
30090 
30091     /* End of the user code for pope . */
30092 
30093 /* User-specified code, instruction-end-c part: beginning. */
30094 
30095 /* User-specified code, instruction-end-c part: end */
30096 
30097     /* Undefine the pope argument macros so they can't be used
30098        by mistake in the instruction body coming next. */
30099 
30100 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30101 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30102 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30103 
30104   }
30105  JITTER_INSTRUCTION_EPILOG_(pope, pope, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30106 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30107 
30108   JITTER_INSTRUCTION_PROLOG_(popend, popend, hot)
30109   {
30110     /* This specialized instruction is not a replacement. */
30111 #   undef JITTER_BRANCH_FAST
30112 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30113 #   undef JITTER_BRANCH_FAST_IF_ZERO
30114 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30115 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30116 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30117 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30118 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30119 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30120 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30121 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30122 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30123 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30124 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30125 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30126 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30127 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30128 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30129 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30130 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30131 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30132 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30133 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30134 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30135 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30136 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30137 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30138 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30139 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30140 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30141 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30142 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30143 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30144 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30145 #   undef JITTER_BRANCH_FAST_IF_AND
30146 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30147 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30148 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30149 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30150 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30151 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30152 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30153 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30154 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30155 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30156 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30157 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30158 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30159 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30160 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30161 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30162 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30163 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30164 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30165 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30166 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30167 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30168 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30169 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30170 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30171 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30172 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30173 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30174 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30175 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       206
30176 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popend
30177 
30178 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popend
30179 
30180   /* The residual arity for this instruction does not depend on fast labels. */
30181   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30182 
30183 
30184 #if defined (JITTER_PROFILE_SAMPLE)
30185   JITTER_PROFILE_SAMPLE_UPDATE
30186      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30187       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30188   /* Force the compiler not move sample-profiling instrumentation
30189      beyond this point; this way the actual user code is timed.
30190      This is still not perfect, as residuals are materialised before
30191      we arrive here, but should be adequate at least for slow VM
30192      instructions. */
30193   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30194 #endif
30195 #if defined (JITTER_PROFILE_COUNT)
30196   /* Notice that, differently from the code above, this
30197      instrumentation code *can* be reordered freely: as long as a
30198      VM instruction is counted, the count increment can be placed
30199      anyehere.  Let GCC move this code and possibly achieve better
30200      throughput by exploiting instruction-level parallelism and
30201      therefore approximate more closely a non-profiled build. */
30202   JITTER_PROFILE_COUNT_UPDATE
30203      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30204       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30205 #endif
30206 
30207 /* User-specified code, instruction-beginning-c part: beginning. */
30208 
30209 /* User-specified code, instruction-beginning-c part: end */
30210 
30211 
30212     /* User code for popend . */
30213 #line 945 "../../libpoke/pvm.jitter"
30214 
30215     uint32_t endian = PVM_VAL_INT (JITTER_TOP_STACK ());
30216     jitter_state_runtime.endian = endian;
30217     JITTER_DROP_STACK ();
30218 
30219     /* End of the user code for popend . */
30220 
30221 /* User-specified code, instruction-end-c part: beginning. */
30222 
30223 /* User-specified code, instruction-end-c part: end */
30224 
30225     /* Undefine the popend argument macros so they can't be used
30226        by mistake in the instruction body coming next. */
30227 
30228 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30229 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30230 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30231 
30232   }
30233  JITTER_INSTRUCTION_EPILOG_(popend, popend, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30234 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30235 
30236   JITTER_INSTRUCTION_PROLOG_(popf/nR, popf__nR, cold)
30237   {
30238     /* This specialized instruction is not a replacement. */
30239 #   undef JITTER_BRANCH_FAST
30240 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30241 #   undef JITTER_BRANCH_FAST_IF_ZERO
30242 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30243 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30244 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30245 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30246 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30247 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30248 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30249 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30250 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30251 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30252 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30253 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30254 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30255 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30256 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30257 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30258 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30259 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30260 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30261 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30262 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30263 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30264 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30265 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30266 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30267 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30268 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30269 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30270 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30271 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30272 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30273 #   undef JITTER_BRANCH_FAST_IF_AND
30274 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30275 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30276 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30277 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30278 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30279 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30280 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30281 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30282 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30283 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30284 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30285 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30286 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30287 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30288 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30289 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30290 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30291 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30292 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30293 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30294 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30295 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30296 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30297 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30298 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30299 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30300 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30301 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30302 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30303 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       207
30304 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popf/nR
30305 
30306 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popf__nR
30307 
30308   /* The residual arity for this instruction does not depend on fast labels. */
30309   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
30310 
30311     /* The 0th argument is a residual literal. */
30312 #if defined(JITTER_DISPATCH_NO_THREADING)
30313 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
30314     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
30315 #elif defined (JITTER_REPLICATE)
30316 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
30317 #else
30318 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
30319 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
30320 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30321 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30322 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30323 #   define JITTER_ARGF0 JITTER_ARGP0
30324 
30325 
30326 #if defined (JITTER_PROFILE_SAMPLE)
30327   JITTER_PROFILE_SAMPLE_UPDATE
30328      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30329       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30330   /* Force the compiler not move sample-profiling instrumentation
30331      beyond this point; this way the actual user code is timed.
30332      This is still not perfect, as residuals are materialised before
30333      we arrive here, but should be adequate at least for slow VM
30334      instructions. */
30335   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30336 #endif
30337 #if defined (JITTER_PROFILE_COUNT)
30338   /* Notice that, differently from the code above, this
30339      instrumentation code *can* be reordered freely: as long as a
30340      VM instruction is counted, the count increment can be placed
30341      anyehere.  Let GCC move this code and possibly achieve better
30342      throughput by exploiting instruction-level parallelism and
30343      therefore approximate more closely a non-profiled build. */
30344   JITTER_PROFILE_COUNT_UPDATE
30345      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30346       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30347 #endif
30348 
30349 /* User-specified code, instruction-beginning-c part: beginning. */
30350 
30351 /* User-specified code, instruction-beginning-c part: end */
30352 
30353 
30354     /* User code for popf/nR . */
30355 #line 1627 "../../libpoke/pvm.jitter"
30356 
30357     jitter_uint i;
30358 
30359     for (i = 0; i < JITTER_ARGN0; ++i)
30360         jitter_state_runtime.env
30361            = pvm_env_pop_frame (jitter_state_runtime.env);
30362 
30363     /* End of the user code for popf/nR . */
30364 
30365 /* User-specified code, instruction-end-c part: beginning. */
30366 
30367 /* User-specified code, instruction-end-c part: end */
30368 
30369     /* Undefine the popf/nR argument macros so they can't be used
30370        by mistake in the instruction body coming next. */
30371 #   undef JITTER_SLOW_REGISTER_OFFSET0
30372 #   undef JITTER_ARG0
30373 #   undef JITTER_ARGN0
30374 #   undef JITTER_ARGU0
30375 #   undef JITTER_ARGP0
30376 #   undef JITTER_ARGF0
30377 
30378 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30379 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30380 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30381 
30382   }
30383  JITTER_INSTRUCTION_EPILOG_(popf/nR, popf__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30384 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30385 
30386   JITTER_INSTRUCTION_PROLOG_(popios, popios, hot)
30387   {
30388     /* This specialized instruction is not a replacement. */
30389 #   undef JITTER_BRANCH_FAST
30390 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30391 #   undef JITTER_BRANCH_FAST_IF_ZERO
30392 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30393 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30394 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30395 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30396 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30397 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30398 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30399 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30400 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30401 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30402 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30403 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30404 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30405 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30406 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30407 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30408 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30409 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30410 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30411 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30412 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30413 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30414 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30415 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30416 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30417 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30418 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30419 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30420 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30421 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30422 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30423 #   undef JITTER_BRANCH_FAST_IF_AND
30424 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30425 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30426 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30427 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30428 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30429 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30430 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30431 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30432 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30433 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30434 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30435 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30436 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30437 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30438 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30439 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30440 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30441 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30442 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30443 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30444 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30445 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30446 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30447 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30448 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30449 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30450 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30451 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30452 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30453 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       208
30454 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popios
30455 
30456 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popios
30457 
30458   /* The residual arity for this instruction does not depend on fast labels. */
30459   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30460 
30461 
30462 #if defined (JITTER_PROFILE_SAMPLE)
30463   JITTER_PROFILE_SAMPLE_UPDATE
30464      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30465       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30466   /* Force the compiler not move sample-profiling instrumentation
30467      beyond this point; this way the actual user code is timed.
30468      This is still not perfect, as residuals are materialised before
30469      we arrive here, but should be adequate at least for slow VM
30470      instructions. */
30471   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30472 #endif
30473 #if defined (JITTER_PROFILE_COUNT)
30474   /* Notice that, differently from the code above, this
30475      instrumentation code *can* be reordered freely: as long as a
30476      VM instruction is counted, the count increment can be placed
30477      anyehere.  Let GCC move this code and possibly achieve better
30478      throughput by exploiting instruction-level parallelism and
30479      therefore approximate more closely a non-profiled build. */
30480   JITTER_PROFILE_COUNT_UPDATE
30481      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30482       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30483 #endif
30484 
30485 /* User-specified code, instruction-beginning-c part: beginning. */
30486 
30487 /* User-specified code, instruction-beginning-c part: end */
30488 
30489 
30490     /* User code for popios . */
30491 #line 1452 "../../libpoke/pvm.jitter"
30492 
30493     ios io = ios_search_by_id (PVM_VAL_INT (JITTER_TOP_STACK ()));
30494 
30495     if (io == NULL)
30496       PVM_RAISE_DFL (PVM_E_NO_IOS);
30497     ios_set_cur (io);
30498     JITTER_DROP_STACK ();
30499 
30500     /* End of the user code for popios . */
30501 
30502 /* User-specified code, instruction-end-c part: beginning. */
30503 
30504 /* User-specified code, instruction-end-c part: end */
30505 
30506     /* Undefine the popios argument macros so they can't be used
30507        by mistake in the instruction body coming next. */
30508 
30509 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30510 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30511 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30512 
30513   }
30514  JITTER_INSTRUCTION_EPILOG_(popios, popios, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30515 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30516 
30517   JITTER_INSTRUCTION_PROLOG_(popoac, popoac, hot)
30518   {
30519     /* This specialized instruction is not a replacement. */
30520 #   undef JITTER_BRANCH_FAST
30521 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30522 #   undef JITTER_BRANCH_FAST_IF_ZERO
30523 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30524 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30525 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30526 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30527 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30528 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30529 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30530 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30531 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30532 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30533 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30534 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30535 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30536 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30537 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30538 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30539 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30540 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30541 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30542 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30543 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30544 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30545 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30546 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30547 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30548 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30549 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30550 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30551 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30552 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30553 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30554 #   undef JITTER_BRANCH_FAST_IF_AND
30555 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30556 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30557 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30558 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30559 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30560 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30561 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30562 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30563 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30564 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30565 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30566 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30567 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30568 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30569 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30570 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30571 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30572 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30573 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30574 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30575 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30576 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30577 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30578 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30579 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30580 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30581 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30582 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30583 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30584 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       209
30585 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popoac
30586 
30587 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popoac
30588 
30589   /* The residual arity for this instruction does not depend on fast labels. */
30590   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30591 
30592 
30593 #if defined (JITTER_PROFILE_SAMPLE)
30594   JITTER_PROFILE_SAMPLE_UPDATE
30595      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30596       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30597   /* Force the compiler not move sample-profiling instrumentation
30598      beyond this point; this way the actual user code is timed.
30599      This is still not perfect, as residuals are materialised before
30600      we arrive here, but should be adequate at least for slow VM
30601      instructions. */
30602   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30603 #endif
30604 #if defined (JITTER_PROFILE_COUNT)
30605   /* Notice that, differently from the code above, this
30606      instrumentation code *can* be reordered freely: as long as a
30607      VM instruction is counted, the count increment can be placed
30608      anyehere.  Let GCC move this code and possibly achieve better
30609      throughput by exploiting instruction-level parallelism and
30610      therefore approximate more closely a non-profiled build. */
30611   JITTER_PROFILE_COUNT_UPDATE
30612      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30613       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30614 #endif
30615 
30616 /* User-specified code, instruction-beginning-c part: beginning. */
30617 
30618 /* User-specified code, instruction-beginning-c part: end */
30619 
30620 
30621     /* User code for popoac . */
30622 #line 1190 "../../libpoke/pvm.jitter"
30623 
30624     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
30625     int oacutoff = PVM_VAL_INT (JITTER_TOP_STACK ());
30626 
30627     pvm_set_oacutoff (vm, oacutoff);
30628     JITTER_DROP_STACK ();
30629 
30630     /* End of the user code for popoac . */
30631 
30632 /* User-specified code, instruction-end-c part: beginning. */
30633 
30634 /* User-specified code, instruction-end-c part: end */
30635 
30636     /* Undefine the popoac argument macros so they can't be used
30637        by mistake in the instruction body coming next. */
30638 
30639 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30640 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30641 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30642 
30643   }
30644  JITTER_INSTRUCTION_EPILOG_(popoac, popoac, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30645 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30646 
30647   JITTER_INSTRUCTION_PROLOG_(popob, popob, hot)
30648   {
30649     /* This specialized instruction is not a replacement. */
30650 #   undef JITTER_BRANCH_FAST
30651 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30652 #   undef JITTER_BRANCH_FAST_IF_ZERO
30653 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30654 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30655 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30656 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30657 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30658 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30659 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30660 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30661 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30662 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30663 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30664 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30665 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30666 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30667 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30668 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30669 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30670 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30671 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30672 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30673 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30674 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30675 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30676 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30677 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30678 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30679 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30680 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30681 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30682 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30683 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30684 #   undef JITTER_BRANCH_FAST_IF_AND
30685 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30686 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30687 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30688 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30689 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30690 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30691 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30692 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30693 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30694 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30695 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30696 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30697 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30698 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30699 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30700 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30701 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30702 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30703 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30704 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30705 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30706 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30707 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30708 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30709 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30710 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30711 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30712 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30713 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30714 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       210
30715 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popob
30716 
30717 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popob
30718 
30719   /* The residual arity for this instruction does not depend on fast labels. */
30720   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30721 
30722 
30723 #if defined (JITTER_PROFILE_SAMPLE)
30724   JITTER_PROFILE_SAMPLE_UPDATE
30725      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30726       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30727   /* Force the compiler not move sample-profiling instrumentation
30728      beyond this point; this way the actual user code is timed.
30729      This is still not perfect, as residuals are materialised before
30730      we arrive here, but should be adequate at least for slow VM
30731      instructions. */
30732   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30733 #endif
30734 #if defined (JITTER_PROFILE_COUNT)
30735   /* Notice that, differently from the code above, this
30736      instrumentation code *can* be reordered freely: as long as a
30737      VM instruction is counted, the count increment can be placed
30738      anyehere.  Let GCC move this code and possibly achieve better
30739      throughput by exploiting instruction-level parallelism and
30740      therefore approximate more closely a non-profiled build. */
30741   JITTER_PROFILE_COUNT_UPDATE
30742      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30743       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30744 #endif
30745 
30746 /* User-specified code, instruction-beginning-c part: beginning. */
30747 
30748 /* User-specified code, instruction-beginning-c part: end */
30749 
30750 
30751     /* User code for popob . */
30752 #line 986 "../../libpoke/pvm.jitter"
30753 
30754     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
30755     int obase = PVM_VAL_INT (JITTER_TOP_STACK ());
30756 
30757     if (obase != 2 && obase != 8 && obase != 10 && obase != 16)
30758       PVM_RAISE (PVM_E_INVAL, "invalid output base", PVM_E_INVAL_ESTATUS);
30759 
30760     pvm_set_obase (vm, obase);
30761     JITTER_DROP_STACK ();
30762 
30763     /* End of the user code for popob . */
30764 
30765 /* User-specified code, instruction-end-c part: beginning. */
30766 
30767 /* User-specified code, instruction-end-c part: end */
30768 
30769     /* Undefine the popob argument macros so they can't be used
30770        by mistake in the instruction body coming next. */
30771 
30772 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30773 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30774 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30775 
30776   }
30777  JITTER_INSTRUCTION_EPILOG_(popob, popob, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30778 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30779 
30780   JITTER_INSTRUCTION_PROLOG_(popobc, popobc, hot)
30781   {
30782     /* This specialized instruction is not a replacement. */
30783 #   undef JITTER_BRANCH_FAST
30784 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30785 #   undef JITTER_BRANCH_FAST_IF_ZERO
30786 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30787 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30788 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30789 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30790 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30791 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30792 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30793 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30794 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30795 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30796 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30797 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30798 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30799 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30800 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30801 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30802 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30803 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30804 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30805 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30806 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30807 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30808 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30809 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30810 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30811 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30812 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30813 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30814 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30815 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30816 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30817 #   undef JITTER_BRANCH_FAST_IF_AND
30818 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30819 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30820 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30821 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30822 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30823 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30824 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30825 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30826 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30827 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30828 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30829 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30830 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30831 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30832 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30833 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30834 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30835 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30836 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30837 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30838 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30839 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30840 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30841 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30842 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30843 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30844 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30845 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30846 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30847 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       211
30848 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popobc
30849 
30850 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popobc
30851 
30852   /* The residual arity for this instruction does not depend on fast labels. */
30853   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30854 
30855 
30856 #if defined (JITTER_PROFILE_SAMPLE)
30857   JITTER_PROFILE_SAMPLE_UPDATE
30858      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30859       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30860   /* Force the compiler not move sample-profiling instrumentation
30861      beyond this point; this way the actual user code is timed.
30862      This is still not perfect, as residuals are materialised before
30863      we arrive here, but should be adequate at least for slow VM
30864      instructions. */
30865   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30866 #endif
30867 #if defined (JITTER_PROFILE_COUNT)
30868   /* Notice that, differently from the code above, this
30869      instrumentation code *can* be reordered freely: as long as a
30870      VM instruction is counted, the count increment can be placed
30871      anyehere.  Let GCC move this code and possibly achieve better
30872      throughput by exploiting instruction-level parallelism and
30873      therefore approximate more closely a non-profiled build. */
30874   JITTER_PROFILE_COUNT_UPDATE
30875      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30876       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30877 #endif
30878 
30879 /* User-specified code, instruction-beginning-c part: beginning. */
30880 
30881 /* User-specified code, instruction-beginning-c part: end */
30882 
30883 
30884     /* User code for popobc . */
30885 #line 1300 "../../libpoke/pvm.jitter"
30886 
30887     struct pk_color color;
30888 
30889     color.blue = PVM_VAL_INT (JITTER_TOP_STACK ());
30890     color.green = PVM_VAL_INT (JITTER_UNDER_TOP_STACK ());
30891     JITTER_DROP_STACK ();
30892     JITTER_DROP_STACK ();
30893     color.red = PVM_VAL_INT (JITTER_TOP_STACK ());
30894     JITTER_DROP_STACK ();
30895 
30896     pk_term_set_bgcolor (color);
30897 
30898     /* End of the user code for popobc . */
30899 
30900 /* User-specified code, instruction-end-c part: beginning. */
30901 
30902 /* User-specified code, instruction-end-c part: end */
30903 
30904     /* Undefine the popobc argument macros so they can't be used
30905        by mistake in the instruction body coming next. */
30906 
30907 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30908 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30909 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30910 
30911   }
30912  JITTER_INSTRUCTION_EPILOG_(popobc, popobc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30913 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30914 
30915   JITTER_INSTRUCTION_PROLOG_(popoc, popoc, hot)
30916   {
30917     /* This specialized instruction is not a replacement. */
30918 #   undef JITTER_BRANCH_FAST
30919 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30920 #   undef JITTER_BRANCH_FAST_IF_ZERO
30921 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30922 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30923 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30924 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30925 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30926 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30927 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30928 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30929 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30930 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30931 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30932 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30933 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30934 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30935 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30936 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30937 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30938 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30939 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30940 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30941 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30942 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30943 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30944 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30945 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30946 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30947 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30948 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30949 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30950 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30951 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30952 #   undef JITTER_BRANCH_FAST_IF_AND
30953 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30954 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30955 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30956 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30957 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30958 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30959 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30960 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30961 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30962 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30963 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30964 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30965 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30966 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30967 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30968 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30969 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30970 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30971 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30972 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30973 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30974 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30975 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30976 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30977 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30978 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30979 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30980 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30981 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30982 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       212
30983 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popoc
30984 
30985 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popoc
30986 
30987   /* The residual arity for this instruction does not depend on fast labels. */
30988   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30989 
30990 
30991 #if defined (JITTER_PROFILE_SAMPLE)
30992   JITTER_PROFILE_SAMPLE_UPDATE
30993      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30994       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30995   /* Force the compiler not move sample-profiling instrumentation
30996      beyond this point; this way the actual user code is timed.
30997      This is still not perfect, as residuals are materialised before
30998      we arrive here, but should be adequate at least for slow VM
30999      instructions. */
31000   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31001 #endif
31002 #if defined (JITTER_PROFILE_COUNT)
31003   /* Notice that, differently from the code above, this
31004      instrumentation code *can* be reordered freely: as long as a
31005      VM instruction is counted, the count increment can be placed
31006      anyehere.  Let GCC move this code and possibly achieve better
31007      throughput by exploiting instruction-level parallelism and
31008      therefore approximate more closely a non-profiled build. */
31009   JITTER_PROFILE_COUNT_UPDATE
31010      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31011       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31012 #endif
31013 
31014 /* User-specified code, instruction-beginning-c part: beginning. */
31015 
31016 /* User-specified code, instruction-beginning-c part: end */
31017 
31018 
31019     /* User code for popoc . */
31020 #line 1261 "../../libpoke/pvm.jitter"
31021 
31022     struct pk_color color;
31023 
31024     color.blue = PVM_VAL_INT (JITTER_TOP_STACK ());
31025     color.green = PVM_VAL_INT (JITTER_UNDER_TOP_STACK ());
31026     JITTER_DROP_STACK ();
31027     JITTER_DROP_STACK ();
31028     color.red = PVM_VAL_INT (JITTER_TOP_STACK ());
31029     JITTER_DROP_STACK ();
31030 
31031     pk_term_set_color (color);
31032 
31033     /* End of the user code for popoc . */
31034 
31035 /* User-specified code, instruction-end-c part: beginning. */
31036 
31037 /* User-specified code, instruction-end-c part: end */
31038 
31039     /* Undefine the popoc argument macros so they can't be used
31040        by mistake in the instruction body coming next. */
31041 
31042 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31043 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31044 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31045 
31046   }
31047  JITTER_INSTRUCTION_EPILOG_(popoc, popoc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31048 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31049 
31050   JITTER_INSTRUCTION_PROLOG_(popod, popod, hot)
31051   {
31052     /* This specialized instruction is not a replacement. */
31053 #   undef JITTER_BRANCH_FAST
31054 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31055 #   undef JITTER_BRANCH_FAST_IF_ZERO
31056 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31057 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31058 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31059 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31060 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31061 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31062 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31063 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31064 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31065 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31066 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31067 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31068 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31069 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31070 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31071 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31072 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31073 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31074 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31075 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31076 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31077 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31078 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31079 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31080 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31081 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31082 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31083 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31084 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31085 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31086 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31087 #   undef JITTER_BRANCH_FAST_IF_AND
31088 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31089 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31090 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31091 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31092 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31093 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31094 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31095 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31096 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31097 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31098 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31099 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31100 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31101 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31102 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31103 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31104 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31105 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31106 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31107 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31108 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31109 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31110 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31111 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31112 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31113 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31114 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31115 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31116 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31117 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       213
31118 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popod
31119 
31120 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popod
31121 
31122   /* The residual arity for this instruction does not depend on fast labels. */
31123   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31124 
31125 
31126 #if defined (JITTER_PROFILE_SAMPLE)
31127   JITTER_PROFILE_SAMPLE_UPDATE
31128      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31129       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31130   /* Force the compiler not move sample-profiling instrumentation
31131      beyond this point; this way the actual user code is timed.
31132      This is still not perfect, as residuals are materialised before
31133      we arrive here, but should be adequate at least for slow VM
31134      instructions. */
31135   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31136 #endif
31137 #if defined (JITTER_PROFILE_COUNT)
31138   /* Notice that, differently from the code above, this
31139      instrumentation code *can* be reordered freely: as long as a
31140      VM instruction is counted, the count increment can be placed
31141      anyehere.  Let GCC move this code and possibly achieve better
31142      throughput by exploiting instruction-level parallelism and
31143      therefore approximate more closely a non-profiled build. */
31144   JITTER_PROFILE_COUNT_UPDATE
31145      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31146       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31147 #endif
31148 
31149 /* User-specified code, instruction-beginning-c part: beginning. */
31150 
31151 /* User-specified code, instruction-beginning-c part: end */
31152 
31153 
31154     /* User code for popod . */
31155 #line 1151 "../../libpoke/pvm.jitter"
31156 
31157     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
31158     int odepth = PVM_VAL_INT (JITTER_TOP_STACK ());
31159 
31160     pvm_set_odepth (vm, odepth);
31161     JITTER_DROP_STACK ();
31162 
31163     /* End of the user code for popod . */
31164 
31165 /* User-specified code, instruction-end-c part: beginning. */
31166 
31167 /* User-specified code, instruction-end-c part: end */
31168 
31169     /* Undefine the popod argument macros so they can't be used
31170        by mistake in the instruction body coming next. */
31171 
31172 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31173 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31174 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31175 
31176   }
31177  JITTER_INSTRUCTION_EPILOG_(popod, popod, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31178 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31179 
31180   JITTER_INSTRUCTION_PROLOG_(popoi, popoi, hot)
31181   {
31182     /* This specialized instruction is not a replacement. */
31183 #   undef JITTER_BRANCH_FAST
31184 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31185 #   undef JITTER_BRANCH_FAST_IF_ZERO
31186 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31187 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31188 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31189 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31190 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31191 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31192 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31193 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31194 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31195 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31196 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31197 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31198 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31199 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31200 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31201 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31202 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31203 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31204 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31205 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31206 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31207 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31208 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31209 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31210 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31211 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31212 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31213 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31214 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31215 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31216 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31217 #   undef JITTER_BRANCH_FAST_IF_AND
31218 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31219 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31220 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31221 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31222 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31223 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31224 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31225 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31226 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31227 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31228 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31229 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31230 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31231 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31232 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31233 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31234 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31235 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31236 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31237 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31238 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31239 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31240 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31241 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31242 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31243 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31244 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31245 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31246 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31247 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       214
31248 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popoi
31249 
31250 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popoi
31251 
31252   /* The residual arity for this instruction does not depend on fast labels. */
31253   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31254 
31255 
31256 #if defined (JITTER_PROFILE_SAMPLE)
31257   JITTER_PROFILE_SAMPLE_UPDATE
31258      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31259       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31260   /* Force the compiler not move sample-profiling instrumentation
31261      beyond this point; this way the actual user code is timed.
31262      This is still not perfect, as residuals are materialised before
31263      we arrive here, but should be adequate at least for slow VM
31264      instructions. */
31265   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31266 #endif
31267 #if defined (JITTER_PROFILE_COUNT)
31268   /* Notice that, differently from the code above, this
31269      instrumentation code *can* be reordered freely: as long as a
31270      VM instruction is counted, the count increment can be placed
31271      anyehere.  Let GCC move this code and possibly achieve better
31272      throughput by exploiting instruction-level parallelism and
31273      therefore approximate more closely a non-profiled build. */
31274   JITTER_PROFILE_COUNT_UPDATE
31275      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31276       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31277 #endif
31278 
31279 /* User-specified code, instruction-beginning-c part: beginning. */
31280 
31281 /* User-specified code, instruction-beginning-c part: end */
31282 
31283 
31284     /* User code for popoi . */
31285 #line 1114 "../../libpoke/pvm.jitter"
31286 
31287     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
31288     int oindent = PVM_VAL_INT (JITTER_TOP_STACK ());
31289 
31290     pvm_set_oindent (vm, oindent);
31291     JITTER_DROP_STACK ();
31292 
31293     /* End of the user code for popoi . */
31294 
31295 /* User-specified code, instruction-end-c part: beginning. */
31296 
31297 /* User-specified code, instruction-end-c part: end */
31298 
31299     /* Undefine the popoi argument macros so they can't be used
31300        by mistake in the instruction body coming next. */
31301 
31302 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31303 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31304 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31305 
31306   }
31307  JITTER_INSTRUCTION_EPILOG_(popoi, popoi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31308 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31309 
31310   JITTER_INSTRUCTION_PROLOG_(popom, popom, hot)
31311   {
31312     /* This specialized instruction is not a replacement. */
31313 #   undef JITTER_BRANCH_FAST
31314 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31315 #   undef JITTER_BRANCH_FAST_IF_ZERO
31316 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31317 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31318 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31319 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31320 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31321 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31322 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31323 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31324 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31325 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31326 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31327 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31328 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31329 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31330 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31331 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31332 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31333 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31334 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31335 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31336 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31337 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31338 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31339 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31340 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31341 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31342 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31343 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31344 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31345 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31346 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31347 #   undef JITTER_BRANCH_FAST_IF_AND
31348 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31349 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31350 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31351 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31352 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31353 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31354 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31355 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31356 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31357 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31358 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31359 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31360 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31361 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31362 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31363 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31364 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31365 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31366 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31367 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31368 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31369 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31370 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31371 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31372 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31373 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31374 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31375 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31376 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31377 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       215
31378 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popom
31379 
31380 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popom
31381 
31382   /* The residual arity for this instruction does not depend on fast labels. */
31383   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31384 
31385 
31386 #if defined (JITTER_PROFILE_SAMPLE)
31387   JITTER_PROFILE_SAMPLE_UPDATE
31388      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31389       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31390   /* Force the compiler not move sample-profiling instrumentation
31391      beyond this point; this way the actual user code is timed.
31392      This is still not perfect, as residuals are materialised before
31393      we arrive here, but should be adequate at least for slow VM
31394      instructions. */
31395   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31396 #endif
31397 #if defined (JITTER_PROFILE_COUNT)
31398   /* Notice that, differently from the code above, this
31399      instrumentation code *can* be reordered freely: as long as a
31400      VM instruction is counted, the count increment can be placed
31401      anyehere.  Let GCC move this code and possibly achieve better
31402      throughput by exploiting instruction-level parallelism and
31403      therefore approximate more closely a non-profiled build. */
31404   JITTER_PROFILE_COUNT_UPDATE
31405      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31406       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31407 #endif
31408 
31409 /* User-specified code, instruction-beginning-c part: beginning. */
31410 
31411 /* User-specified code, instruction-beginning-c part: end */
31412 
31413 
31414     /* User code for popom . */
31415 #line 1032 "../../libpoke/pvm.jitter"
31416 
31417     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
31418     int omode = PVM_VAL_INT (JITTER_TOP_STACK ());
31419 
31420     if (omode != PVM_PRINT_FLAT && omode != PVM_PRINT_TREE)
31421       PVM_RAISE (PVM_E_INVAL, "invalid output mode", PVM_E_INVAL_ESTATUS);
31422 
31423     pvm_set_omode (vm, omode);
31424     JITTER_DROP_STACK ();
31425 
31426     /* End of the user code for popom . */
31427 
31428 /* User-specified code, instruction-end-c part: beginning. */
31429 
31430 /* User-specified code, instruction-end-c part: end */
31431 
31432     /* Undefine the popom argument macros so they can't be used
31433        by mistake in the instruction body coming next. */
31434 
31435 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31436 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31437 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31438 
31439   }
31440  JITTER_INSTRUCTION_EPILOG_(popom, popom, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31441 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31442 
31443   JITTER_INSTRUCTION_PROLOG_(popoo, popoo, hot)
31444   {
31445     /* This specialized instruction is not a replacement. */
31446 #   undef JITTER_BRANCH_FAST
31447 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31448 #   undef JITTER_BRANCH_FAST_IF_ZERO
31449 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31450 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31451 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31452 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31453 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31454 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31455 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31456 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31457 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31458 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31459 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31460 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31461 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31462 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31463 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31464 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31465 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31466 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31467 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31468 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31469 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31470 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31471 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31472 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31473 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31474 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31475 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31476 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31477 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31478 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31479 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31480 #   undef JITTER_BRANCH_FAST_IF_AND
31481 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31482 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31483 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31484 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31485 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31486 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31487 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31488 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31489 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31490 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31491 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31492 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31493 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31494 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31495 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31496 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31497 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31498 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31499 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31500 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31501 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31502 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31503 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31504 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31505 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31506 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31507 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31508 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31509 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31510 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       216
31511 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popoo
31512 
31513 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popoo
31514 
31515   /* The residual arity for this instruction does not depend on fast labels. */
31516   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31517 
31518 
31519 #if defined (JITTER_PROFILE_SAMPLE)
31520   JITTER_PROFILE_SAMPLE_UPDATE
31521      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31522       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31523   /* Force the compiler not move sample-profiling instrumentation
31524      beyond this point; this way the actual user code is timed.
31525      This is still not perfect, as residuals are materialised before
31526      we arrive here, but should be adequate at least for slow VM
31527      instructions. */
31528   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31529 #endif
31530 #if defined (JITTER_PROFILE_COUNT)
31531   /* Notice that, differently from the code above, this
31532      instrumentation code *can* be reordered freely: as long as a
31533      VM instruction is counted, the count increment can be placed
31534      anyehere.  Let GCC move this code and possibly achieve better
31535      throughput by exploiting instruction-level parallelism and
31536      therefore approximate more closely a non-profiled build. */
31537   JITTER_PROFILE_COUNT_UPDATE
31538      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31539       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31540 #endif
31541 
31542 /* User-specified code, instruction-beginning-c part: beginning. */
31543 
31544 /* User-specified code, instruction-beginning-c part: end */
31545 
31546 
31547     /* User code for popoo . */
31548 #line 1073 "../../libpoke/pvm.jitter"
31549 
31550     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
31551     int omaps = PVM_VAL_INT (JITTER_TOP_STACK ());
31552 
31553     pvm_set_omaps (vm, omaps);
31554     JITTER_DROP_STACK ();
31555 
31556     /* End of the user code for popoo . */
31557 
31558 /* User-specified code, instruction-end-c part: beginning. */
31559 
31560 /* User-specified code, instruction-end-c part: end */
31561 
31562     /* Undefine the popoo argument macros so they can't be used
31563        by mistake in the instruction body coming next. */
31564 
31565 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31566 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31567 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31568 
31569   }
31570  JITTER_INSTRUCTION_EPILOG_(popoo, popoo, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31571 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31572 
31573   JITTER_INSTRUCTION_PROLOG_(popopp, popopp, hot)
31574   {
31575     /* This specialized instruction is not a replacement. */
31576 #   undef JITTER_BRANCH_FAST
31577 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31578 #   undef JITTER_BRANCH_FAST_IF_ZERO
31579 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31580 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31581 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31582 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31583 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31584 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31585 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31586 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31587 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31588 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31589 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31590 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31591 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31592 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31593 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31594 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31595 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31596 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31597 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31598 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31599 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31600 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31601 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31602 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31603 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31604 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31605 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31606 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31607 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31608 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31609 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31610 #   undef JITTER_BRANCH_FAST_IF_AND
31611 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31612 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31613 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31614 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31615 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31616 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31617 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31618 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31619 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31620 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31621 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31622 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31623 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31624 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31625 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31626 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31627 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31628 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31629 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31630 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31631 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31632 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31633 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31634 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31635 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31636 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31637 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31638 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31639 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31640 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       217
31641 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popopp
31642 
31643 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popopp
31644 
31645   /* The residual arity for this instruction does not depend on fast labels. */
31646   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31647 
31648 
31649 #if defined (JITTER_PROFILE_SAMPLE)
31650   JITTER_PROFILE_SAMPLE_UPDATE
31651      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31652       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31653   /* Force the compiler not move sample-profiling instrumentation
31654      beyond this point; this way the actual user code is timed.
31655      This is still not perfect, as residuals are materialised before
31656      we arrive here, but should be adequate at least for slow VM
31657      instructions. */
31658   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31659 #endif
31660 #if defined (JITTER_PROFILE_COUNT)
31661   /* Notice that, differently from the code above, this
31662      instrumentation code *can* be reordered freely: as long as a
31663      VM instruction is counted, the count increment can be placed
31664      anyehere.  Let GCC move this code and possibly achieve better
31665      throughput by exploiting instruction-level parallelism and
31666      therefore approximate more closely a non-profiled build. */
31667   JITTER_PROFILE_COUNT_UPDATE
31668      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31669       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31670 #endif
31671 
31672 /* User-specified code, instruction-beginning-c part: beginning. */
31673 
31674 /* User-specified code, instruction-beginning-c part: end */
31675 
31676 
31677     /* User code for popopp . */
31678 #line 1227 "../../libpoke/pvm.jitter"
31679 
31680     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
31681     int pp = PVM_VAL_INT (JITTER_TOP_STACK ());
31682 
31683     pvm_set_pretty_print (vm, pp);
31684     JITTER_DROP_STACK ();
31685 
31686     /* End of the user code for popopp . */
31687 
31688 /* User-specified code, instruction-end-c part: beginning. */
31689 
31690 /* User-specified code, instruction-end-c part: end */
31691 
31692     /* Undefine the popopp argument macros so they can't be used
31693        by mistake in the instruction body coming next. */
31694 
31695 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31696 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31697 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31698 
31699   }
31700  JITTER_INSTRUCTION_EPILOG_(popopp, popopp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31701 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31702 
31703   JITTER_INSTRUCTION_PROLOG_(popr/%rR, popr___rrR, cold)
31704   {
31705     /* This specialized instruction is not a replacement. */
31706 #   undef JITTER_BRANCH_FAST
31707 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31708 #   undef JITTER_BRANCH_FAST_IF_ZERO
31709 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31710 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31711 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31712 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31713 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31714 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31715 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31716 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31717 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31718 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31719 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31720 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31721 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31722 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31723 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31724 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31725 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31726 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31727 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31728 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31729 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31730 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31731 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31732 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31733 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31734 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31735 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31736 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31737 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31738 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31739 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31740 #   undef JITTER_BRANCH_FAST_IF_AND
31741 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31742 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31743 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31744 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31745 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31746 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31747 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31748 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31749 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31750 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31751 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31752 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31753 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31754 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31755 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31756 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31757 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31758 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31759 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31760 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31761 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31762 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31763 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31764 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31765 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31766 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31767 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31768 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31769 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31770 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       218
31771 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popr/%rR
31772 
31773 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popr___rrR
31774 
31775   /* The residual arity for this instruction does not depend on fast labels. */
31776   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
31777 
31778     /* The 0th argument is a slow (therefore residual, passed as an offset)
31779         register. */
31780   /* Define a macro expanding to the slow register offset. */
31781 #if defined(JITTER_DISPATCH_NO_THREADING)
31782 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
31783 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
31784 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
31785 #else
31786 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
31787 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31788   /* Define a macro expanding to an l-value for the VM register content. */
31789 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
31790 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31791 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31792 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31793 #   define JITTER_ARGF0 JITTER_ARGP0
31794 
31795 
31796 #if defined (JITTER_PROFILE_SAMPLE)
31797   JITTER_PROFILE_SAMPLE_UPDATE
31798      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31799       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31800   /* Force the compiler not move sample-profiling instrumentation
31801      beyond this point; this way the actual user code is timed.
31802      This is still not perfect, as residuals are materialised before
31803      we arrive here, but should be adequate at least for slow VM
31804      instructions. */
31805   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31806 #endif
31807 #if defined (JITTER_PROFILE_COUNT)
31808   /* Notice that, differently from the code above, this
31809      instrumentation code *can* be reordered freely: as long as a
31810      VM instruction is counted, the count increment can be placed
31811      anyehere.  Let GCC move this code and possibly achieve better
31812      throughput by exploiting instruction-level parallelism and
31813      therefore approximate more closely a non-profiled build. */
31814   JITTER_PROFILE_COUNT_UPDATE
31815      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31816       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31817 #endif
31818 
31819 /* User-specified code, instruction-beginning-c part: beginning. */
31820 
31821 /* User-specified code, instruction-beginning-c part: end */
31822 
31823 
31824     /* User code for popr/%rR . */
31825 #line 2191 "../../libpoke/pvm.jitter"
31826 
31827     JITTER_ARG0 = JITTER_TOP_STACK ();
31828     JITTER_DROP_STACK ();
31829 
31830     /* End of the user code for popr/%rR . */
31831 
31832 /* User-specified code, instruction-end-c part: beginning. */
31833 
31834 /* User-specified code, instruction-end-c part: end */
31835 
31836     /* Undefine the popr/%rR argument macros so they can't be used
31837        by mistake in the instruction body coming next. */
31838 #   undef JITTER_SLOW_REGISTER_OFFSET0
31839 #   undef JITTER_ARG0
31840 #   undef JITTER_ARGN0
31841 #   undef JITTER_ARGU0
31842 #   undef JITTER_ARGP0
31843 #   undef JITTER_ARGF0
31844 
31845 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31846 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31847 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31848 
31849   }
31850  JITTER_INSTRUCTION_EPILOG_(popr/%rR, popr___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31851 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31852 
31853   JITTER_INSTRUCTION_PROLOG_(popvar/nR/nR, popvar__nR__nR, cold)
31854   {
31855     /* This specialized instruction is not a replacement. */
31856 #   undef JITTER_BRANCH_FAST
31857 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31858 #   undef JITTER_BRANCH_FAST_IF_ZERO
31859 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31860 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31861 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31862 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31863 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31864 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31865 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31866 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31867 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31868 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31869 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31870 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31871 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31872 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31873 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31874 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31875 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31876 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31877 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31878 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31879 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31880 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31881 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31882 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31883 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31884 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31885 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31886 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31887 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31888 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31889 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31890 #   undef JITTER_BRANCH_FAST_IF_AND
31891 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31892 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31893 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31894 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31895 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31896 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31897 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31898 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31899 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31900 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31901 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31902 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31903 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31904 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31905 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31906 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31907 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31908 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31909 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31910 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31911 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31912 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31913 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31914 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31915 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31916 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31917 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31918 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31919 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31920 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       219
31921 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         popvar/nR/nR
31922 
31923 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME popvar__nR__nR
31924 
31925   /* The residual arity for this instruction does not depend on fast labels. */
31926   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
31927 
31928     /* The 0th argument is a residual literal. */
31929 #if defined(JITTER_DISPATCH_NO_THREADING)
31930 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
31931     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
31932 #elif defined (JITTER_REPLICATE)
31933 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
31934 #else
31935 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
31936 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31937 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31938 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31939 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31940 #   define JITTER_ARGF0 JITTER_ARGP0
31941 
31942     /* The 1th argument is a residual literal. */
31943 #if defined(JITTER_DISPATCH_NO_THREADING)
31944 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
31945     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
31946 #elif defined (JITTER_REPLICATE)
31947 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
31948 #else
31949 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
31950 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31951 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
31952 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
31953 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
31954 #   define JITTER_ARGF1 JITTER_ARGP1
31955 
31956 
31957 #if defined (JITTER_PROFILE_SAMPLE)
31958   JITTER_PROFILE_SAMPLE_UPDATE
31959      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31960       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31961   /* Force the compiler not move sample-profiling instrumentation
31962      beyond this point; this way the actual user code is timed.
31963      This is still not perfect, as residuals are materialised before
31964      we arrive here, but should be adequate at least for slow VM
31965      instructions. */
31966   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31967 #endif
31968 #if defined (JITTER_PROFILE_COUNT)
31969   /* Notice that, differently from the code above, this
31970      instrumentation code *can* be reordered freely: as long as a
31971      VM instruction is counted, the count increment can be placed
31972      anyehere.  Let GCC move this code and possibly achieve better
31973      throughput by exploiting instruction-level parallelism and
31974      therefore approximate more closely a non-profiled build. */
31975   JITTER_PROFILE_COUNT_UPDATE
31976      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31977       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31978 #endif
31979 
31980 /* User-specified code, instruction-beginning-c part: beginning. */
31981 
31982 /* User-specified code, instruction-beginning-c part: end */
31983 
31984 
31985     /* User code for popvar/nR/nR . */
31986 #line 1686 "../../libpoke/pvm.jitter"
31987 
31988     pvm_env_set_var (jitter_state_runtime.env,
31989                      (int) JITTER_ARGN0,
31990                      (int) JITTER_ARGN1,
31991                      JITTER_TOP_STACK ());
31992     JITTER_DROP_STACK ();
31993 
31994     /* End of the user code for popvar/nR/nR . */
31995 
31996 /* User-specified code, instruction-end-c part: beginning. */
31997 
31998 /* User-specified code, instruction-end-c part: end */
31999 
32000     /* Undefine the popvar/nR/nR argument macros so they can't be used
32001        by mistake in the instruction body coming next. */
32002 #   undef JITTER_SLOW_REGISTER_OFFSET0
32003 #   undef JITTER_ARG0
32004 #   undef JITTER_ARGN0
32005 #   undef JITTER_ARGU0
32006 #   undef JITTER_ARGP0
32007 #   undef JITTER_ARGF0
32008 #   undef JITTER_SLOW_REGISTER_OFFSET1
32009 #   undef JITTER_ARG1
32010 #   undef JITTER_ARGN1
32011 #   undef JITTER_ARGU1
32012 #   undef JITTER_ARGP1
32013 #   undef JITTER_ARGF1
32014 
32015 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32016 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32017 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32018 
32019   }
32020  JITTER_INSTRUCTION_EPILOG_(popvar/nR/nR, popvar__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32021 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32022 
32023   JITTER_INSTRUCTION_PROLOG_(powi, powi, hot)
32024   {
32025     /* This specialized instruction is not a replacement. */
32026 #   undef JITTER_BRANCH_FAST
32027 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32028 #   undef JITTER_BRANCH_FAST_IF_ZERO
32029 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32030 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32031 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32032 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32033 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32034 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32035 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32036 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32037 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32038 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32039 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32040 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32041 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32042 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32043 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32044 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32045 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32046 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32047 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32048 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32049 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32050 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32051 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32052 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32053 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32054 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32055 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32056 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32057 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32058 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32059 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32060 #   undef JITTER_BRANCH_FAST_IF_AND
32061 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32062 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32063 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32064 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32065 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32066 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32067 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32068 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32069 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32070 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32071 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32072 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32073 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32074 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32075 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32076 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32077 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32078 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32079 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32080 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32081 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32082 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32083 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32084 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32085 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32086 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32087 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32088 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32089 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32090 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       220
32091 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         powi
32092 
32093 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME powi
32094 
32095   /* The residual arity for this instruction does not depend on fast labels. */
32096   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32097 
32098 
32099 #if defined (JITTER_PROFILE_SAMPLE)
32100   JITTER_PROFILE_SAMPLE_UPDATE
32101      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32102       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32103   /* Force the compiler not move sample-profiling instrumentation
32104      beyond this point; this way the actual user code is timed.
32105      This is still not perfect, as residuals are materialised before
32106      we arrive here, but should be adequate at least for slow VM
32107      instructions. */
32108   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32109 #endif
32110 #if defined (JITTER_PROFILE_COUNT)
32111   /* Notice that, differently from the code above, this
32112      instrumentation code *can* be reordered freely: as long as a
32113      VM instruction is counted, the count increment can be placed
32114      anyehere.  Let GCC move this code and possibly achieve better
32115      throughput by exploiting instruction-level parallelism and
32116      therefore approximate more closely a non-profiled build. */
32117   JITTER_PROFILE_COUNT_UPDATE
32118      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32119       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32120 #endif
32121 
32122 /* User-specified code, instruction-beginning-c part: beginning. */
32123 
32124 /* User-specified code, instruction-beginning-c part: end */
32125 
32126 
32127     /* User code for powi . */
32128 #line 2623 "../../libpoke/pvm.jitter"
32129 
32130     PVM_POWOP_SIGNED (INT,int64_t,int);
32131 
32132     /* End of the user code for powi . */
32133 
32134 /* User-specified code, instruction-end-c part: beginning. */
32135 
32136 /* User-specified code, instruction-end-c part: end */
32137 
32138     /* Undefine the powi argument macros so they can't be used
32139        by mistake in the instruction body coming next. */
32140 
32141 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32142 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32143 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32144 
32145   }
32146  JITTER_INSTRUCTION_EPILOG_(powi, powi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32147 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32148 
32149   JITTER_INSTRUCTION_PROLOG_(powiu, powiu, hot)
32150   {
32151     /* This specialized instruction is not a replacement. */
32152 #   undef JITTER_BRANCH_FAST
32153 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32154 #   undef JITTER_BRANCH_FAST_IF_ZERO
32155 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32156 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32157 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32158 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32159 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32160 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32161 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32162 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32163 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32164 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32165 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32166 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32167 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32168 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32169 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32170 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32171 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32172 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32173 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32174 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32175 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32176 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32177 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32178 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32179 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32180 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32181 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32182 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32183 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32184 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32185 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32186 #   undef JITTER_BRANCH_FAST_IF_AND
32187 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32188 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32189 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32190 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32191 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32192 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32193 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32194 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32195 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32196 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32197 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32198 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32199 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32200 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32201 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32202 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32203 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32204 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32205 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32206 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32207 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32208 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32209 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32210 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32211 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32212 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32213 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32214 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32215 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32216 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       221
32217 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         powiu
32218 
32219 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME powiu
32220 
32221   /* The residual arity for this instruction does not depend on fast labels. */
32222   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32223 
32224 
32225 #if defined (JITTER_PROFILE_SAMPLE)
32226   JITTER_PROFILE_SAMPLE_UPDATE
32227      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32228       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32229   /* Force the compiler not move sample-profiling instrumentation
32230      beyond this point; this way the actual user code is timed.
32231      This is still not perfect, as residuals are materialised before
32232      we arrive here, but should be adequate at least for slow VM
32233      instructions. */
32234   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32235 #endif
32236 #if defined (JITTER_PROFILE_COUNT)
32237   /* Notice that, differently from the code above, this
32238      instrumentation code *can* be reordered freely: as long as a
32239      VM instruction is counted, the count increment can be placed
32240      anyehere.  Let GCC move this code and possibly achieve better
32241      throughput by exploiting instruction-level parallelism and
32242      therefore approximate more closely a non-profiled build. */
32243   JITTER_PROFILE_COUNT_UPDATE
32244      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32245       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32246 #endif
32247 
32248 /* User-specified code, instruction-beginning-c part: beginning. */
32249 
32250 /* User-specified code, instruction-beginning-c part: end */
32251 
32252 
32253     /* User code for powiu . */
32254 #line 2637 "../../libpoke/pvm.jitter"
32255 
32256     PVM_POWOP (UINT,uint64_t,uint);
32257 
32258     /* End of the user code for powiu . */
32259 
32260 /* User-specified code, instruction-end-c part: beginning. */
32261 
32262 /* User-specified code, instruction-end-c part: end */
32263 
32264     /* Undefine the powiu argument macros so they can't be used
32265        by mistake in the instruction body coming next. */
32266 
32267 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32268 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32269 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32270 
32271   }
32272  JITTER_INSTRUCTION_EPILOG_(powiu, powiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32273 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32274 
32275   JITTER_INSTRUCTION_PROLOG_(powl, powl, hot)
32276   {
32277     /* This specialized instruction is not a replacement. */
32278 #   undef JITTER_BRANCH_FAST
32279 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32280 #   undef JITTER_BRANCH_FAST_IF_ZERO
32281 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32282 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32283 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32284 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32285 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32286 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32287 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32288 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32289 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32290 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32291 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32292 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32293 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32294 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32295 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32296 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32297 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32298 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32299 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32300 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32301 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32302 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32303 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32304 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32305 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32306 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32307 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32308 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32309 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32310 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32311 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32312 #   undef JITTER_BRANCH_FAST_IF_AND
32313 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32314 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32315 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32316 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32317 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32318 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32319 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32320 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32321 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32322 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32323 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32324 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32325 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32326 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32327 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32328 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32329 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32330 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32331 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32332 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32333 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32334 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32335 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32336 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32337 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32338 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32339 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32340 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32341 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32342 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       222
32343 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         powl
32344 
32345 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME powl
32346 
32347   /* The residual arity for this instruction does not depend on fast labels. */
32348   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32349 
32350 
32351 #if defined (JITTER_PROFILE_SAMPLE)
32352   JITTER_PROFILE_SAMPLE_UPDATE
32353      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32354       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32355   /* Force the compiler not move sample-profiling instrumentation
32356      beyond this point; this way the actual user code is timed.
32357      This is still not perfect, as residuals are materialised before
32358      we arrive here, but should be adequate at least for slow VM
32359      instructions. */
32360   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32361 #endif
32362 #if defined (JITTER_PROFILE_COUNT)
32363   /* Notice that, differently from the code above, this
32364      instrumentation code *can* be reordered freely: as long as a
32365      VM instruction is counted, the count increment can be placed
32366      anyehere.  Let GCC move this code and possibly achieve better
32367      throughput by exploiting instruction-level parallelism and
32368      therefore approximate more closely a non-profiled build. */
32369   JITTER_PROFILE_COUNT_UPDATE
32370      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32371       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32372 #endif
32373 
32374 /* User-specified code, instruction-beginning-c part: beginning. */
32375 
32376 /* User-specified code, instruction-beginning-c part: end */
32377 
32378 
32379     /* User code for powl . */
32380 #line 2651 "../../libpoke/pvm.jitter"
32381 
32382     PVM_POWOP_SIGNED (LONG,int64_t,long);
32383 
32384     /* End of the user code for powl . */
32385 
32386 /* User-specified code, instruction-end-c part: beginning. */
32387 
32388 /* User-specified code, instruction-end-c part: end */
32389 
32390     /* Undefine the powl argument macros so they can't be used
32391        by mistake in the instruction body coming next. */
32392 
32393 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32394 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32395 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32396 
32397   }
32398  JITTER_INSTRUCTION_EPILOG_(powl, powl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32399 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32400 
32401   JITTER_INSTRUCTION_PROLOG_(powlu, powlu, hot)
32402   {
32403     /* This specialized instruction is not a replacement. */
32404 #   undef JITTER_BRANCH_FAST
32405 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32406 #   undef JITTER_BRANCH_FAST_IF_ZERO
32407 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32408 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32409 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32410 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32411 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32412 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32413 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32414 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32415 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32416 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32417 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32418 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32419 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32420 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32421 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32422 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32423 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32424 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32425 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32426 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32427 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32428 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32429 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32430 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32431 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32432 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32433 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32434 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32435 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32436 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32437 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32438 #   undef JITTER_BRANCH_FAST_IF_AND
32439 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32440 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32441 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32442 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32443 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32444 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32445 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32446 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32447 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32448 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32449 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32450 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32451 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32452 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32453 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32454 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32455 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32456 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32457 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32458 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32459 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32460 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32461 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32462 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32463 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32464 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32465 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32466 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32467 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32468 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       223
32469 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         powlu
32470 
32471 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME powlu
32472 
32473   /* The residual arity for this instruction does not depend on fast labels. */
32474   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32475 
32476 
32477 #if defined (JITTER_PROFILE_SAMPLE)
32478   JITTER_PROFILE_SAMPLE_UPDATE
32479      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32480       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32481   /* Force the compiler not move sample-profiling instrumentation
32482      beyond this point; this way the actual user code is timed.
32483      This is still not perfect, as residuals are materialised before
32484      we arrive here, but should be adequate at least for slow VM
32485      instructions. */
32486   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32487 #endif
32488 #if defined (JITTER_PROFILE_COUNT)
32489   /* Notice that, differently from the code above, this
32490      instrumentation code *can* be reordered freely: as long as a
32491      VM instruction is counted, the count increment can be placed
32492      anyehere.  Let GCC move this code and possibly achieve better
32493      throughput by exploiting instruction-level parallelism and
32494      therefore approximate more closely a non-profiled build. */
32495   JITTER_PROFILE_COUNT_UPDATE
32496      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32497       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32498 #endif
32499 
32500 /* User-specified code, instruction-beginning-c part: beginning. */
32501 
32502 /* User-specified code, instruction-beginning-c part: end */
32503 
32504 
32505     /* User code for powlu . */
32506 #line 2665 "../../libpoke/pvm.jitter"
32507 
32508     PVM_POWOP (ULONG,uint64_t,ulong);
32509 
32510     /* End of the user code for powlu . */
32511 
32512 /* User-specified code, instruction-end-c part: beginning. */
32513 
32514 /* User-specified code, instruction-end-c part: end */
32515 
32516     /* Undefine the powlu argument macros so they can't be used
32517        by mistake in the instruction body coming next. */
32518 
32519 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32520 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32521 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32522 
32523   }
32524  JITTER_INSTRUCTION_EPILOG_(powlu, powlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32525 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32526 
32527   JITTER_INSTRUCTION_PROLOG_(printi/nR, printi__nR, cold)
32528   {
32529     /* This specialized instruction is not a replacement. */
32530 #   undef JITTER_BRANCH_FAST
32531 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32532 #   undef JITTER_BRANCH_FAST_IF_ZERO
32533 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32534 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32535 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32536 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32537 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32538 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32539 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32540 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32541 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32542 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32543 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32544 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32545 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32546 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32547 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32548 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32549 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32550 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32551 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32552 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32553 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32554 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32555 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32556 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32557 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32558 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32559 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32560 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32561 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32562 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32563 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32564 #   undef JITTER_BRANCH_FAST_IF_AND
32565 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32566 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32567 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32568 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32569 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32570 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32571 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32572 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32573 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32574 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32575 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32576 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32577 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32578 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32579 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32580 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32581 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32582 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32583 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32584 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32585 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32586 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32587 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32588 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32589 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32590 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32591 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32592 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32593 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32594 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       224
32595 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         printi/nR
32596 
32597 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME printi__nR
32598 
32599   /* The residual arity for this instruction does not depend on fast labels. */
32600   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
32601 
32602     /* The 0th argument is a residual literal. */
32603 #if defined(JITTER_DISPATCH_NO_THREADING)
32604 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
32605     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
32606 #elif defined (JITTER_REPLICATE)
32607 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
32608 #else
32609 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
32610 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32611 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32612 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32613 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32614 #   define JITTER_ARGF0 JITTER_ARGP0
32615 
32616 
32617 #if defined (JITTER_PROFILE_SAMPLE)
32618   JITTER_PROFILE_SAMPLE_UPDATE
32619      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32620       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32621   /* Force the compiler not move sample-profiling instrumentation
32622      beyond this point; this way the actual user code is timed.
32623      This is still not perfect, as residuals are materialised before
32624      we arrive here, but should be adequate at least for slow VM
32625      instructions. */
32626   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32627 #endif
32628 #if defined (JITTER_PROFILE_COUNT)
32629   /* Notice that, differently from the code above, this
32630      instrumentation code *can* be reordered freely: as long as a
32631      VM instruction is counted, the count increment can be placed
32632      anyehere.  Let GCC move this code and possibly achieve better
32633      throughput by exploiting instruction-level parallelism and
32634      therefore approximate more closely a non-profiled build. */
32635   JITTER_PROFILE_COUNT_UPDATE
32636      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32637       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32638 #endif
32639 
32640 /* User-specified code, instruction-beginning-c part: beginning. */
32641 
32642 /* User-specified code, instruction-beginning-c part: end */
32643 
32644 
32645     /* User code for printi/nR . */
32646 #line 1779 "../../libpoke/pvm.jitter"
32647 
32648     int base = PVM_VAL_INT (JITTER_TOP_STACK ());
32649     PVM_PRINTI (INT, int32_t, 'd', base);
32650 
32651     /* End of the user code for printi/nR . */
32652 
32653 /* User-specified code, instruction-end-c part: beginning. */
32654 
32655 /* User-specified code, instruction-end-c part: end */
32656 
32657     /* Undefine the printi/nR argument macros so they can't be used
32658        by mistake in the instruction body coming next. */
32659 #   undef JITTER_SLOW_REGISTER_OFFSET0
32660 #   undef JITTER_ARG0
32661 #   undef JITTER_ARGN0
32662 #   undef JITTER_ARGU0
32663 #   undef JITTER_ARGP0
32664 #   undef JITTER_ARGF0
32665 
32666 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32667 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32668 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32669 
32670   }
32671  JITTER_INSTRUCTION_EPILOG_(printi/nR, printi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32672 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32673 
32674   JITTER_INSTRUCTION_PROLOG_(printiu/nR, printiu__nR, cold)
32675   {
32676     /* This specialized instruction is not a replacement. */
32677 #   undef JITTER_BRANCH_FAST
32678 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32679 #   undef JITTER_BRANCH_FAST_IF_ZERO
32680 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32681 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32682 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32683 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32684 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32685 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32686 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32687 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32688 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32689 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32690 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32691 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32692 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32693 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32694 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32695 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32696 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32697 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32698 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32699 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32700 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32701 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32702 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32703 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32704 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32705 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32706 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32707 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32708 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32709 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32710 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32711 #   undef JITTER_BRANCH_FAST_IF_AND
32712 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32713 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32714 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32715 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32716 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32717 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32718 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32719 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32720 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32721 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32722 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32723 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32724 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32725 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32726 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32727 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32728 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32729 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32730 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32731 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32732 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32733 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32734 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32735 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32736 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32737 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32738 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32739 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32740 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32741 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       225
32742 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         printiu/nR
32743 
32744 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME printiu__nR
32745 
32746   /* The residual arity for this instruction does not depend on fast labels. */
32747   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
32748 
32749     /* The 0th argument is a residual literal. */
32750 #if defined(JITTER_DISPATCH_NO_THREADING)
32751 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
32752     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
32753 #elif defined (JITTER_REPLICATE)
32754 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
32755 #else
32756 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
32757 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32758 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32759 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32760 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32761 #   define JITTER_ARGF0 JITTER_ARGP0
32762 
32763 
32764 #if defined (JITTER_PROFILE_SAMPLE)
32765   JITTER_PROFILE_SAMPLE_UPDATE
32766      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32767       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32768   /* Force the compiler not move sample-profiling instrumentation
32769      beyond this point; this way the actual user code is timed.
32770      This is still not perfect, as residuals are materialised before
32771      we arrive here, but should be adequate at least for slow VM
32772      instructions. */
32773   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32774 #endif
32775 #if defined (JITTER_PROFILE_COUNT)
32776   /* Notice that, differently from the code above, this
32777      instrumentation code *can* be reordered freely: as long as a
32778      VM instruction is counted, the count increment can be placed
32779      anyehere.  Let GCC move this code and possibly achieve better
32780      throughput by exploiting instruction-level parallelism and
32781      therefore approximate more closely a non-profiled build. */
32782   JITTER_PROFILE_COUNT_UPDATE
32783      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32784       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32785 #endif
32786 
32787 /* User-specified code, instruction-beginning-c part: beginning. */
32788 
32789 /* User-specified code, instruction-beginning-c part: end */
32790 
32791 
32792     /* User code for printiu/nR . */
32793 #line 1793 "../../libpoke/pvm.jitter"
32794 
32795     int base = PVM_VAL_INT (JITTER_TOP_STACK ());
32796     PVM_PRINTI (UINT, uint32_t, 'u', base);
32797 
32798     /* End of the user code for printiu/nR . */
32799 
32800 /* User-specified code, instruction-end-c part: beginning. */
32801 
32802 /* User-specified code, instruction-end-c part: end */
32803 
32804     /* Undefine the printiu/nR argument macros so they can't be used
32805        by mistake in the instruction body coming next. */
32806 #   undef JITTER_SLOW_REGISTER_OFFSET0
32807 #   undef JITTER_ARG0
32808 #   undef JITTER_ARGN0
32809 #   undef JITTER_ARGU0
32810 #   undef JITTER_ARGP0
32811 #   undef JITTER_ARGF0
32812 
32813 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32814 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32815 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32816 
32817   }
32818  JITTER_INSTRUCTION_EPILOG_(printiu/nR, printiu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32819 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32820 
32821   JITTER_INSTRUCTION_PROLOG_(printl/nR, printl__nR, cold)
32822   {
32823     /* This specialized instruction is not a replacement. */
32824 #   undef JITTER_BRANCH_FAST
32825 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32826 #   undef JITTER_BRANCH_FAST_IF_ZERO
32827 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32828 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32829 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32830 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32831 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32832 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32833 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32834 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32835 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32836 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32837 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32838 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32839 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32840 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32841 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32842 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32843 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32844 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32845 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32846 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32847 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32848 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32849 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32850 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32851 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32852 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32853 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32854 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32855 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32856 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32857 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32858 #   undef JITTER_BRANCH_FAST_IF_AND
32859 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32860 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32861 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32862 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32863 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32864 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32865 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32866 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32867 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32868 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32869 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32870 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32871 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32872 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32873 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32874 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32875 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32876 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32877 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32878 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32879 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32880 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32881 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32882 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32883 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32884 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32885 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32886 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32887 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32888 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       226
32889 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         printl/nR
32890 
32891 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME printl__nR
32892 
32893   /* The residual arity for this instruction does not depend on fast labels. */
32894   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
32895 
32896     /* The 0th argument is a residual literal. */
32897 #if defined(JITTER_DISPATCH_NO_THREADING)
32898 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
32899     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
32900 #elif defined (JITTER_REPLICATE)
32901 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
32902 #else
32903 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
32904 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32905 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32906 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32907 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32908 #   define JITTER_ARGF0 JITTER_ARGP0
32909 
32910 
32911 #if defined (JITTER_PROFILE_SAMPLE)
32912   JITTER_PROFILE_SAMPLE_UPDATE
32913      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32914       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32915   /* Force the compiler not move sample-profiling instrumentation
32916      beyond this point; this way the actual user code is timed.
32917      This is still not perfect, as residuals are materialised before
32918      we arrive here, but should be adequate at least for slow VM
32919      instructions. */
32920   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32921 #endif
32922 #if defined (JITTER_PROFILE_COUNT)
32923   /* Notice that, differently from the code above, this
32924      instrumentation code *can* be reordered freely: as long as a
32925      VM instruction is counted, the count increment can be placed
32926      anyehere.  Let GCC move this code and possibly achieve better
32927      throughput by exploiting instruction-level parallelism and
32928      therefore approximate more closely a non-profiled build. */
32929   JITTER_PROFILE_COUNT_UPDATE
32930      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32931       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32932 #endif
32933 
32934 /* User-specified code, instruction-beginning-c part: beginning. */
32935 
32936 /* User-specified code, instruction-beginning-c part: end */
32937 
32938 
32939     /* User code for printl/nR . */
32940 #line 1807 "../../libpoke/pvm.jitter"
32941 
32942     int base = PVM_VAL_INT (JITTER_TOP_STACK ());
32943     PVM_PRINTL (LONG, int64_t, 'd', base);
32944 
32945     /* End of the user code for printl/nR . */
32946 
32947 /* User-specified code, instruction-end-c part: beginning. */
32948 
32949 /* User-specified code, instruction-end-c part: end */
32950 
32951     /* Undefine the printl/nR argument macros so they can't be used
32952        by mistake in the instruction body coming next. */
32953 #   undef JITTER_SLOW_REGISTER_OFFSET0
32954 #   undef JITTER_ARG0
32955 #   undef JITTER_ARGN0
32956 #   undef JITTER_ARGU0
32957 #   undef JITTER_ARGP0
32958 #   undef JITTER_ARGF0
32959 
32960 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32961 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32962 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32963 
32964   }
32965  JITTER_INSTRUCTION_EPILOG_(printl/nR, printl__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32966 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32967 
32968   JITTER_INSTRUCTION_PROLOG_(printlu/nR, printlu__nR, cold)
32969   {
32970     /* This specialized instruction is not a replacement. */
32971 #   undef JITTER_BRANCH_FAST
32972 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32973 #   undef JITTER_BRANCH_FAST_IF_ZERO
32974 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32975 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32976 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32977 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32978 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32979 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32980 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32981 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32982 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32983 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32984 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32985 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32986 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32987 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32988 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32989 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32990 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32991 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32992 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32993 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32994 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32995 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32996 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32997 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32998 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32999 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33000 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33001 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33002 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33003 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33004 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33005 #   undef JITTER_BRANCH_FAST_IF_AND
33006 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33007 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33008 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33009 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33010 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33011 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33012 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33013 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33014 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33015 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33016 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33017 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33018 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33019 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33020 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33021 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33022 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33023 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33024 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33025 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33026 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33027 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33028 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33029 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33030 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33031 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33032 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33033 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33034 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33035 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       227
33036 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         printlu/nR
33037 
33038 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME printlu__nR
33039 
33040   /* The residual arity for this instruction does not depend on fast labels. */
33041   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
33042 
33043     /* The 0th argument is a residual literal. */
33044 #if defined(JITTER_DISPATCH_NO_THREADING)
33045 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
33046     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
33047 #elif defined (JITTER_REPLICATE)
33048 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
33049 #else
33050 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
33051 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33052 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33053 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33054 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33055 #   define JITTER_ARGF0 JITTER_ARGP0
33056 
33057 
33058 #if defined (JITTER_PROFILE_SAMPLE)
33059   JITTER_PROFILE_SAMPLE_UPDATE
33060      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33061       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33062   /* Force the compiler not move sample-profiling instrumentation
33063      beyond this point; this way the actual user code is timed.
33064      This is still not perfect, as residuals are materialised before
33065      we arrive here, but should be adequate at least for slow VM
33066      instructions. */
33067   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33068 #endif
33069 #if defined (JITTER_PROFILE_COUNT)
33070   /* Notice that, differently from the code above, this
33071      instrumentation code *can* be reordered freely: as long as a
33072      VM instruction is counted, the count increment can be placed
33073      anyehere.  Let GCC move this code and possibly achieve better
33074      throughput by exploiting instruction-level parallelism and
33075      therefore approximate more closely a non-profiled build. */
33076   JITTER_PROFILE_COUNT_UPDATE
33077      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33078       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33079 #endif
33080 
33081 /* User-specified code, instruction-beginning-c part: beginning. */
33082 
33083 /* User-specified code, instruction-beginning-c part: end */
33084 
33085 
33086     /* User code for printlu/nR . */
33087 #line 1821 "../../libpoke/pvm.jitter"
33088 
33089    int base = PVM_VAL_INT (JITTER_TOP_STACK ());
33090    PVM_PRINTL (ULONG, uint64_t, 'u', base);
33091 
33092     /* End of the user code for printlu/nR . */
33093 
33094 /* User-specified code, instruction-end-c part: beginning. */
33095 
33096 /* User-specified code, instruction-end-c part: end */
33097 
33098     /* Undefine the printlu/nR argument macros so they can't be used
33099        by mistake in the instruction body coming next. */
33100 #   undef JITTER_SLOW_REGISTER_OFFSET0
33101 #   undef JITTER_ARG0
33102 #   undef JITTER_ARGN0
33103 #   undef JITTER_ARGU0
33104 #   undef JITTER_ARGP0
33105 #   undef JITTER_ARGF0
33106 
33107 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33108 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33109 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33110 
33111   }
33112  JITTER_INSTRUCTION_EPILOG_(printlu/nR, printlu__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33113 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33114 
33115   JITTER_INSTRUCTION_PROLOG_(prints, prints, hot)
33116   {
33117     /* This specialized instruction is not a replacement. */
33118 #   undef JITTER_BRANCH_FAST
33119 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33120 #   undef JITTER_BRANCH_FAST_IF_ZERO
33121 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33122 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33123 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33124 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33125 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33126 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33127 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33128 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33129 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33130 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33131 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33132 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33133 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33134 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33135 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33136 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33137 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33138 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33139 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33140 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33141 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33142 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33143 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33144 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33145 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33146 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33147 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33148 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33149 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33150 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33151 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33152 #   undef JITTER_BRANCH_FAST_IF_AND
33153 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33154 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33155 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33156 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33157 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33158 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33159 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33160 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33161 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33162 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33163 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33164 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33165 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33166 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33167 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33168 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33169 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33170 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33171 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33172 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33173 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33174 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33175 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33176 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33177 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33178 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33179 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33180 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33181 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33182 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       228
33183 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         prints
33184 
33185 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME prints
33186 
33187   /* The residual arity for this instruction does not depend on fast labels. */
33188   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
33189 
33190 
33191 #if defined (JITTER_PROFILE_SAMPLE)
33192   JITTER_PROFILE_SAMPLE_UPDATE
33193      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33194       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33195   /* Force the compiler not move sample-profiling instrumentation
33196      beyond this point; this way the actual user code is timed.
33197      This is still not perfect, as residuals are materialised before
33198      we arrive here, but should be adequate at least for slow VM
33199      instructions. */
33200   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33201 #endif
33202 #if defined (JITTER_PROFILE_COUNT)
33203   /* Notice that, differently from the code above, this
33204      instrumentation code *can* be reordered freely: as long as a
33205      VM instruction is counted, the count increment can be placed
33206      anyehere.  Let GCC move this code and possibly achieve better
33207      throughput by exploiting instruction-level parallelism and
33208      therefore approximate more closely a non-profiled build. */
33209   JITTER_PROFILE_COUNT_UPDATE
33210      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33211       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33212 #endif
33213 
33214 /* User-specified code, instruction-beginning-c part: beginning. */
33215 
33216 /* User-specified code, instruction-beginning-c part: end */
33217 
33218 
33219     /* User code for prints . */
33220 #line 1834 "../../libpoke/pvm.jitter"
33221 
33222     pvm_print_string (JITTER_TOP_STACK ());
33223     JITTER_DROP_STACK ();
33224 
33225     /* End of the user code for prints . */
33226 
33227 /* User-specified code, instruction-end-c part: beginning. */
33228 
33229 /* User-specified code, instruction-end-c part: end */
33230 
33231     /* Undefine the prints argument macros so they can't be used
33232        by mistake in the instruction body coming next. */
33233 
33234 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33235 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33236 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33237 
33238   }
33239  JITTER_INSTRUCTION_EPILOG_(prints, prints, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33240 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33241 
33242   JITTER_INSTRUCTION_PROLOG_(prolog, prolog, hot)
33243   {
33244     /* This specialized instruction is not a replacement. */
33245 #   undef JITTER_BRANCH_FAST
33246 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33247 #   undef JITTER_BRANCH_FAST_IF_ZERO
33248 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33249 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33250 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33251 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33252 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33253 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33254 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33255 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33256 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33257 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33258 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33259 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33260 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33261 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33262 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33263 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33264 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33265 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33266 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33267 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33268 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33269 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33270 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33271 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33272 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33273 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33274 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33275 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33276 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33277 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33278 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33279 #   undef JITTER_BRANCH_FAST_IF_AND
33280 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33281 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33282 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33283 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33284 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33285 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33286 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33287 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33288 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33289 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33290 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33291 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33292 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33293 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33294 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33295 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33296 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33297 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33298 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33299 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33300 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33301 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33302 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33303 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33304 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33305 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33306 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33307 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33308 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33309 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       229
33310 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         prolog
33311 
33312 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME prolog
33313 
33314   /* The residual arity for this instruction does not depend on fast labels. */
33315   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
33316 
33317 
33318   /* This specialized instruction is a callee.  Set the link
33319      pointer if needed... */
33320   union jitter_word _jitter_the_link;
33321   _JITTER_PROCEDURE_PROLOG (_jitter_the_link);
33322   /* ...And make it accessible to this instruction, read-only,
33323      through a macro. */
33324   #define JITTER_LINK \
33325     ((const void *) \
33326      (_jitter_the_link.pointer))
33327 
33328 #if defined (JITTER_PROFILE_SAMPLE)
33329   JITTER_PROFILE_SAMPLE_UPDATE
33330      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33331       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33332   /* Force the compiler not move sample-profiling instrumentation
33333      beyond this point; this way the actual user code is timed.
33334      This is still not perfect, as residuals are materialised before
33335      we arrive here, but should be adequate at least for slow VM
33336      instructions. */
33337   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33338 #endif
33339 #if defined (JITTER_PROFILE_COUNT)
33340   /* Notice that, differently from the code above, this
33341      instrumentation code *can* be reordered freely: as long as a
33342      VM instruction is counted, the count increment can be placed
33343      anyehere.  Let GCC move this code and possibly achieve better
33344      throughput by exploiting instruction-level parallelism and
33345      therefore approximate more closely a non-profiled build. */
33346   JITTER_PROFILE_COUNT_UPDATE
33347      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33348       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33349 #endif
33350 
33351 /* User-specified code, instruction-beginning-c part: beginning. */
33352 
33353 /* User-specified code, instruction-beginning-c part: end */
33354 
33355 
33356     /* User code for prolog . */
33357 #line 1570 "../../libpoke/pvm.jitter"
33358 
33359     /* Fill the return stack slot with the return address.  The return
33360        stack has already been pushesd (with an unspecified value on the
33361        under top) by the caller. */
33362     JITTER_UNDER_TOP_RETURNSTACK() = (jitter_uint) JITTER_LINK;
33363 
33364     /* End of the user code for prolog . */
33365 
33366 /* User-specified code, instruction-end-c part: beginning. */
33367 
33368 /* User-specified code, instruction-end-c part: end */
33369 
33370     /* Undefine the prolog argument macros so they can't be used
33371        by mistake in the instruction body coming next. */
33372 
33373 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33374 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33375 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33376 
33377   }
33378   /* Undefine the link macro. */
33379 #   undef JITTER_LINK
33380 
33381  JITTER_INSTRUCTION_EPILOG_(prolog, prolog, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33382 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33383 
33384   JITTER_INSTRUCTION_PROLOG_(push/nR, push__nR, cold)
33385   {
33386     /* This specialized instruction is not a replacement. */
33387 #   undef JITTER_BRANCH_FAST
33388 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33389 #   undef JITTER_BRANCH_FAST_IF_ZERO
33390 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33391 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33392 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33393 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33394 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33395 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33396 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33397 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33398 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33399 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33400 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33401 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33402 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33403 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33404 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33405 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33406 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33407 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33408 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33409 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33410 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33411 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33412 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33413 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33414 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33415 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33416 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33417 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33418 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33419 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33420 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33421 #   undef JITTER_BRANCH_FAST_IF_AND
33422 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33423 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33424 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33425 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33426 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33427 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33428 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33429 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33430 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33431 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33432 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33433 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33434 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33435 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33436 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33437 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33438 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33439 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33440 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33441 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33442 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33443 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33444 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33445 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33446 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33447 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33448 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33449 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33450 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33451 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       230
33452 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push/nR
33453 
33454 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push__nR
33455 
33456   /* The residual arity for this instruction does not depend on fast labels. */
33457   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
33458 
33459     /* The 0th argument is a residual literal. */
33460 #if defined(JITTER_DISPATCH_NO_THREADING)
33461 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
33462     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
33463 #elif defined (JITTER_REPLICATE)
33464 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
33465 #else
33466 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
33467 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33468 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33469 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33470 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33471 #   define JITTER_ARGF0 JITTER_ARGP0
33472 
33473 
33474 #if defined (JITTER_PROFILE_SAMPLE)
33475   JITTER_PROFILE_SAMPLE_UPDATE
33476      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33477       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33478   /* Force the compiler not move sample-profiling instrumentation
33479      beyond this point; this way the actual user code is timed.
33480      This is still not perfect, as residuals are materialised before
33481      we arrive here, but should be adequate at least for slow VM
33482      instructions. */
33483   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33484 #endif
33485 #if defined (JITTER_PROFILE_COUNT)
33486   /* Notice that, differently from the code above, this
33487      instrumentation code *can* be reordered freely: as long as a
33488      VM instruction is counted, the count increment can be placed
33489      anyehere.  Let GCC move this code and possibly achieve better
33490      throughput by exploiting instruction-level parallelism and
33491      therefore approximate more closely a non-profiled build. */
33492   JITTER_PROFILE_COUNT_UPDATE
33493      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33494       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33495 #endif
33496 
33497 /* User-specified code, instruction-beginning-c part: beginning. */
33498 
33499 /* User-specified code, instruction-beginning-c part: end */
33500 
33501 
33502     /* User code for push/nR . */
33503 #line 1918 "../../libpoke/pvm.jitter"
33504 
33505     pvm_val k = JITTER_ARGN0;
33506     JITTER_PUSH_STACK(k);
33507 
33508     /* End of the user code for push/nR . */
33509 
33510 /* User-specified code, instruction-end-c part: beginning. */
33511 
33512 /* User-specified code, instruction-end-c part: end */
33513 
33514     /* Undefine the push/nR argument macros so they can't be used
33515        by mistake in the instruction body coming next. */
33516 #   undef JITTER_SLOW_REGISTER_OFFSET0
33517 #   undef JITTER_ARG0
33518 #   undef JITTER_ARGN0
33519 #   undef JITTER_ARGU0
33520 #   undef JITTER_ARGP0
33521 #   undef JITTER_ARGF0
33522 
33523 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33524 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33525 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33526 
33527   }
33528  JITTER_INSTRUCTION_EPILOG_(push/nR, push__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33529 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33530 
33531   JITTER_INSTRUCTION_PROLOG_(push/lR, push__lR, hot)
33532   {
33533     /* This specialized instruction is not a replacement. */
33534 #   undef JITTER_BRANCH_FAST
33535 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33536 #   undef JITTER_BRANCH_FAST_IF_ZERO
33537 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33538 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33539 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33540 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33541 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33542 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33543 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33544 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33545 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33546 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33547 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33548 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33549 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33550 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33551 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33552 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33553 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33554 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33555 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33556 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33557 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33558 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33559 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33560 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33561 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33562 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33563 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33564 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33565 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33566 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33567 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33568 #   undef JITTER_BRANCH_FAST_IF_AND
33569 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33570 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33571 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33572 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33573 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33574 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33575 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33576 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33577 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33578 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33579 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33580 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33581 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33582 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33583 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33584 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33585 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33586 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33587 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33588 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33589 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33590 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33591 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33592 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33593 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33594 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33595 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33596 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33597 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33598 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       231
33599 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push/lR
33600 
33601 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push__lR
33602 
33603   /* The residual arity for this instruction does not depend on fast labels. */
33604   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
33605 
33606     /* The 0th argument is a residual label. */
33607 #if defined(JITTER_DISPATCH_NO_THREADING)
33608 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
33609     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
33610 #elif defined (JITTER_REPLICATE)
33611 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
33612 #else
33613 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
33614 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33615 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33616 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33617 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33618 #   define JITTER_ARGF0 JITTER_ARGP0
33619 
33620 
33621 #if defined (JITTER_PROFILE_SAMPLE)
33622   JITTER_PROFILE_SAMPLE_UPDATE
33623      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33624       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33625   /* Force the compiler not move sample-profiling instrumentation
33626      beyond this point; this way the actual user code is timed.
33627      This is still not perfect, as residuals are materialised before
33628      we arrive here, but should be adequate at least for slow VM
33629      instructions. */
33630   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33631 #endif
33632 #if defined (JITTER_PROFILE_COUNT)
33633   /* Notice that, differently from the code above, this
33634      instrumentation code *can* be reordered freely: as long as a
33635      VM instruction is counted, the count increment can be placed
33636      anyehere.  Let GCC move this code and possibly achieve better
33637      throughput by exploiting instruction-level parallelism and
33638      therefore approximate more closely a non-profiled build. */
33639   JITTER_PROFILE_COUNT_UPDATE
33640      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33641       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33642 #endif
33643 
33644 /* User-specified code, instruction-beginning-c part: beginning. */
33645 
33646 /* User-specified code, instruction-beginning-c part: end */
33647 
33648 
33649     /* User code for push/lR . */
33650 #line 1918 "../../libpoke/pvm.jitter"
33651 
33652     pvm_val k = JITTER_ARGN0;
33653     JITTER_PUSH_STACK(k);
33654 
33655     /* End of the user code for push/lR . */
33656 
33657 /* User-specified code, instruction-end-c part: beginning. */
33658 
33659 /* User-specified code, instruction-end-c part: end */
33660 
33661     /* Undefine the push/lR argument macros so they can't be used
33662        by mistake in the instruction body coming next. */
33663 #   undef JITTER_SLOW_REGISTER_OFFSET0
33664 #   undef JITTER_ARG0
33665 #   undef JITTER_ARGN0
33666 #   undef JITTER_ARGU0
33667 #   undef JITTER_ARGP0
33668 #   undef JITTER_ARGF0
33669 
33670 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33671 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33672 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33673 
33674   }
33675  JITTER_INSTRUCTION_EPILOG_(push/lR, push__lR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33676 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33677 
33678   JITTER_INSTRUCTION_PROLOG_(push32/nR, push32__nR, cold)
33679   {
33680     /* This specialized instruction is not a replacement. */
33681 #   undef JITTER_BRANCH_FAST
33682 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33683 #   undef JITTER_BRANCH_FAST_IF_ZERO
33684 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33685 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33686 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33687 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33688 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33689 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33690 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33691 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33692 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33693 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33694 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33695 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33696 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33697 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33698 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33699 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33700 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33701 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33702 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33703 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33704 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33705 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33706 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33707 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33708 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33709 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33710 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33711 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33712 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33713 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33714 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33715 #   undef JITTER_BRANCH_FAST_IF_AND
33716 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33717 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33718 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33719 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33720 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33721 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33722 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33723 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33724 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33725 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33726 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33727 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33728 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33729 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33730 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33731 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33732 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33733 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33734 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33735 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33736 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33737 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33738 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33739 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33740 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33741 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33742 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33743 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33744 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33745 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       232
33746 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push32/nR
33747 
33748 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push32__nR
33749 
33750   /* The residual arity for this instruction does not depend on fast labels. */
33751   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
33752 
33753     /* The 0th argument is a residual literal. */
33754 #if defined(JITTER_DISPATCH_NO_THREADING)
33755 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
33756     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
33757 #elif defined (JITTER_REPLICATE)
33758 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
33759 #else
33760 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
33761 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33762 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33763 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33764 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33765 #   define JITTER_ARGF0 JITTER_ARGP0
33766 
33767 
33768 #if defined (JITTER_PROFILE_SAMPLE)
33769   JITTER_PROFILE_SAMPLE_UPDATE
33770      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33771       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33772   /* Force the compiler not move sample-profiling instrumentation
33773      beyond this point; this way the actual user code is timed.
33774      This is still not perfect, as residuals are materialised before
33775      we arrive here, but should be adequate at least for slow VM
33776      instructions. */
33777   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33778 #endif
33779 #if defined (JITTER_PROFILE_COUNT)
33780   /* Notice that, differently from the code above, this
33781      instrumentation code *can* be reordered freely: as long as a
33782      VM instruction is counted, the count increment can be placed
33783      anyehere.  Let GCC move this code and possibly achieve better
33784      throughput by exploiting instruction-level parallelism and
33785      therefore approximate more closely a non-profiled build. */
33786   JITTER_PROFILE_COUNT_UPDATE
33787      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33788       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33789 #endif
33790 
33791 /* User-specified code, instruction-beginning-c part: beginning. */
33792 
33793 /* User-specified code, instruction-beginning-c part: end */
33794 
33795 
33796     /* User code for push32/nR . */
33797 #line 2162 "../../libpoke/pvm.jitter"
33798 
33799     pvm_val k = JITTER_ARGN0;
33800     JITTER_PUSH_STACK (k);
33801 
33802     /* End of the user code for push32/nR . */
33803 
33804 /* User-specified code, instruction-end-c part: beginning. */
33805 
33806 /* User-specified code, instruction-end-c part: end */
33807 
33808     /* Undefine the push32/nR argument macros so they can't be used
33809        by mistake in the instruction body coming next. */
33810 #   undef JITTER_SLOW_REGISTER_OFFSET0
33811 #   undef JITTER_ARG0
33812 #   undef JITTER_ARGN0
33813 #   undef JITTER_ARGU0
33814 #   undef JITTER_ARGP0
33815 #   undef JITTER_ARGF0
33816 
33817 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33818 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33819 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33820 
33821   }
33822  JITTER_INSTRUCTION_EPILOG_(push32/nR, push32__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33823 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33824 
33825   JITTER_INSTRUCTION_PROLOG_(push32/lR, push32__lR, hot)
33826   {
33827     /* This specialized instruction is not a replacement. */
33828 #   undef JITTER_BRANCH_FAST
33829 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33830 #   undef JITTER_BRANCH_FAST_IF_ZERO
33831 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33832 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33833 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33834 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33835 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33836 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33837 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33838 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33839 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33840 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33841 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33842 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33843 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33844 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33845 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33846 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33847 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33848 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33849 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33850 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33851 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33852 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33853 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33854 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33855 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33856 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33857 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33858 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33859 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33860 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33861 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33862 #   undef JITTER_BRANCH_FAST_IF_AND
33863 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33864 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33865 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33866 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33867 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33868 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33869 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33870 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33871 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33872 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33873 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33874 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33875 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33876 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33877 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33878 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33879 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33880 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33881 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33882 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33883 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33884 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33885 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33886 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33887 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33888 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33889 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33890 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33891 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33892 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       233
33893 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push32/lR
33894 
33895 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push32__lR
33896 
33897   /* The residual arity for this instruction does not depend on fast labels. */
33898   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
33899 
33900     /* The 0th argument is a residual label. */
33901 #if defined(JITTER_DISPATCH_NO_THREADING)
33902 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
33903     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
33904 #elif defined (JITTER_REPLICATE)
33905 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
33906 #else
33907 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
33908 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33909 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33910 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33911 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33912 #   define JITTER_ARGF0 JITTER_ARGP0
33913 
33914 
33915 #if defined (JITTER_PROFILE_SAMPLE)
33916   JITTER_PROFILE_SAMPLE_UPDATE
33917      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33918       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33919   /* Force the compiler not move sample-profiling instrumentation
33920      beyond this point; this way the actual user code is timed.
33921      This is still not perfect, as residuals are materialised before
33922      we arrive here, but should be adequate at least for slow VM
33923      instructions. */
33924   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33925 #endif
33926 #if defined (JITTER_PROFILE_COUNT)
33927   /* Notice that, differently from the code above, this
33928      instrumentation code *can* be reordered freely: as long as a
33929      VM instruction is counted, the count increment can be placed
33930      anyehere.  Let GCC move this code and possibly achieve better
33931      throughput by exploiting instruction-level parallelism and
33932      therefore approximate more closely a non-profiled build. */
33933   JITTER_PROFILE_COUNT_UPDATE
33934      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33935       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33936 #endif
33937 
33938 /* User-specified code, instruction-beginning-c part: beginning. */
33939 
33940 /* User-specified code, instruction-beginning-c part: end */
33941 
33942 
33943     /* User code for push32/lR . */
33944 #line 2162 "../../libpoke/pvm.jitter"
33945 
33946     pvm_val k = JITTER_ARGN0;
33947     JITTER_PUSH_STACK (k);
33948 
33949     /* End of the user code for push32/lR . */
33950 
33951 /* User-specified code, instruction-end-c part: beginning. */
33952 
33953 /* User-specified code, instruction-end-c part: end */
33954 
33955     /* Undefine the push32/lR argument macros so they can't be used
33956        by mistake in the instruction body coming next. */
33957 #   undef JITTER_SLOW_REGISTER_OFFSET0
33958 #   undef JITTER_ARG0
33959 #   undef JITTER_ARGN0
33960 #   undef JITTER_ARGU0
33961 #   undef JITTER_ARGP0
33962 #   undef JITTER_ARGF0
33963 
33964 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33965 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33966 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33967 
33968   }
33969  JITTER_INSTRUCTION_EPILOG_(push32/lR, push32__lR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33970 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33971 
33972   JITTER_INSTRUCTION_PROLOG_(pushe/lR, pushe__lR, hot)
33973   {
33974     /* This specialized instruction is not a replacement. */
33975 #   undef JITTER_BRANCH_FAST
33976 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33977 #   undef JITTER_BRANCH_FAST_IF_ZERO
33978 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33979 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33980 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33981 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33982 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33983 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33984 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33985 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33986 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33987 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33988 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33989 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33990 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33991 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33992 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33993 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33994 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33995 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33996 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33997 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33998 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33999 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34000 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34001 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34002 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34003 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34004 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34005 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34006 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34007 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34008 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34009 #   undef JITTER_BRANCH_FAST_IF_AND
34010 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34011 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34012 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34013 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34014 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34015 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34016 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34017 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34018 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34019 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34020 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34021 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34022 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34023 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34024 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34025 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34026 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34027 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34028 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34029 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34030 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34031 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34032 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34033 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34034 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34035 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34036 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34037 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34038 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34039 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       234
34040 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushe/lR
34041 
34042 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushe__lR
34043 
34044   /* The residual arity for this instruction does not depend on fast labels. */
34045   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
34046 
34047     /* The 0th argument is a residual label. */
34048 #if defined(JITTER_DISPATCH_NO_THREADING)
34049 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
34050     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
34051 #elif defined (JITTER_REPLICATE)
34052 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
34053 #else
34054 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
34055 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
34056 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34057 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34058 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34059 #   define JITTER_ARGF0 JITTER_ARGP0
34060 
34061 
34062 #if defined (JITTER_PROFILE_SAMPLE)
34063   JITTER_PROFILE_SAMPLE_UPDATE
34064      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34065       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34066   /* Force the compiler not move sample-profiling instrumentation
34067      beyond this point; this way the actual user code is timed.
34068      This is still not perfect, as residuals are materialised before
34069      we arrive here, but should be adequate at least for slow VM
34070      instructions. */
34071   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34072 #endif
34073 #if defined (JITTER_PROFILE_COUNT)
34074   /* Notice that, differently from the code above, this
34075      instrumentation code *can* be reordered freely: as long as a
34076      VM instruction is counted, the count increment can be placed
34077      anyehere.  Let GCC move this code and possibly achieve better
34078      throughput by exploiting instruction-level parallelism and
34079      therefore approximate more closely a non-profiled build. */
34080   JITTER_PROFILE_COUNT_UPDATE
34081      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34082       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34083 #endif
34084 
34085 /* User-specified code, instruction-beginning-c part: beginning. */
34086 
34087 /* User-specified code, instruction-beginning-c part: end */
34088 
34089 
34090     /* User code for pushe/lR . */
34091 #line 5559 "../../libpoke/pvm.jitter"
34092 
34093    struct pvm_exception_handler ehandler;
34094    pvm_val exception = JITTER_TOP_STACK ();
34095    pvm_val exception_code = pvm_ref_struct_cstr (exception, "code");
34096 
34097    ehandler.exception = PVM_VAL_INT (exception_code);
34098    JITTER_DROP_STACK ();
34099    ehandler.main_stack_height = JITTER_HEIGHT_STACK ();
34100    ehandler.return_stack_height = JITTER_HEIGHT_RETURNSTACK ();
34101    ehandler.code = JITTER_ARGP0;
34102    ehandler.env = jitter_state_runtime.env;
34103 
34104    JITTER_PUSH_EXCEPTIONSTACK (ehandler);
34105 
34106     /* End of the user code for pushe/lR . */
34107 
34108 /* User-specified code, instruction-end-c part: beginning. */
34109 
34110 /* User-specified code, instruction-end-c part: end */
34111 
34112     /* Undefine the pushe/lR argument macros so they can't be used
34113        by mistake in the instruction body coming next. */
34114 #   undef JITTER_SLOW_REGISTER_OFFSET0
34115 #   undef JITTER_ARG0
34116 #   undef JITTER_ARGN0
34117 #   undef JITTER_ARGU0
34118 #   undef JITTER_ARGP0
34119 #   undef JITTER_ARGF0
34120 
34121 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34122 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34123 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34124 
34125   }
34126  JITTER_INSTRUCTION_EPILOG_(pushe/lR, pushe__lR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34127 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34128 
34129   JITTER_INSTRUCTION_PROLOG_(pushend, pushend, hot)
34130   {
34131     /* This specialized instruction is not a replacement. */
34132 #   undef JITTER_BRANCH_FAST
34133 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34134 #   undef JITTER_BRANCH_FAST_IF_ZERO
34135 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34136 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34137 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34138 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34139 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34140 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34141 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34142 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34143 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34144 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34145 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34146 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34147 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34148 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34149 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34150 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34151 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34152 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34153 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34154 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34155 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34156 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34157 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34158 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34159 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34160 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34161 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34162 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34163 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34164 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34165 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34166 #   undef JITTER_BRANCH_FAST_IF_AND
34167 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34168 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34169 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34170 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34171 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34172 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34173 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34174 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34175 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34176 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34177 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34178 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34179 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34180 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34181 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34182 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34183 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34184 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34185 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34186 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34187 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34188 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34189 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34190 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34191 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34192 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34193 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34194 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34195 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34196 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       235
34197 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushend
34198 
34199 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushend
34200 
34201   /* The residual arity for this instruction does not depend on fast labels. */
34202   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
34203 
34204 
34205 #if defined (JITTER_PROFILE_SAMPLE)
34206   JITTER_PROFILE_SAMPLE_UPDATE
34207      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34208       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34209   /* Force the compiler not move sample-profiling instrumentation
34210      beyond this point; this way the actual user code is timed.
34211      This is still not perfect, as residuals are materialised before
34212      we arrive here, but should be adequate at least for slow VM
34213      instructions. */
34214   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34215 #endif
34216 #if defined (JITTER_PROFILE_COUNT)
34217   /* Notice that, differently from the code above, this
34218      instrumentation code *can* be reordered freely: as long as a
34219      VM instruction is counted, the count increment can be placed
34220      anyehere.  Let GCC move this code and possibly achieve better
34221      throughput by exploiting instruction-level parallelism and
34222      therefore approximate more closely a non-profiled build. */
34223   JITTER_PROFILE_COUNT_UPDATE
34224      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34225       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34226 #endif
34227 
34228 /* User-specified code, instruction-beginning-c part: beginning. */
34229 
34230 /* User-specified code, instruction-beginning-c part: end */
34231 
34232 
34233     /* User code for pushend . */
34234 #line 930 "../../libpoke/pvm.jitter"
34235 
34236     JITTER_PUSH_STACK (PVM_MAKE_INT (jitter_state_runtime.endian,
34237                                      32));
34238 
34239     /* End of the user code for pushend . */
34240 
34241 /* User-specified code, instruction-end-c part: beginning. */
34242 
34243 /* User-specified code, instruction-end-c part: end */
34244 
34245     /* Undefine the pushend argument macros so they can't be used
34246        by mistake in the instruction body coming next. */
34247 
34248 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34249 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34250 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34251 
34252   }
34253  JITTER_INSTRUCTION_EPILOG_(pushend, pushend, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34254 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34255 
34256   JITTER_INSTRUCTION_PROLOG_(pushf/nR, pushf__nR, cold)
34257   {
34258     /* This specialized instruction is not a replacement. */
34259 #   undef JITTER_BRANCH_FAST
34260 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34261 #   undef JITTER_BRANCH_FAST_IF_ZERO
34262 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34263 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34264 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34265 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34266 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34267 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34268 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34269 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34270 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34271 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34272 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34273 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34274 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34275 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34276 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34277 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34278 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34279 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34280 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34281 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34282 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34283 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34284 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34285 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34286 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34287 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34288 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34289 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34290 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34291 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34292 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34293 #   undef JITTER_BRANCH_FAST_IF_AND
34294 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34295 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34296 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34297 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34298 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34299 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34300 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34301 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34302 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34303 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34304 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34305 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34306 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34307 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34308 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34309 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34310 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34311 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34312 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34313 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34314 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34315 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34316 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34317 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34318 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34319 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34320 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34321 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34322 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34323 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       236
34324 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushf/nR
34325 
34326 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushf__nR
34327 
34328   /* The residual arity for this instruction does not depend on fast labels. */
34329   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
34330 
34331     /* The 0th argument is a residual literal. */
34332 #if defined(JITTER_DISPATCH_NO_THREADING)
34333 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
34334     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
34335 #elif defined (JITTER_REPLICATE)
34336 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
34337 #else
34338 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
34339 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
34340 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34341 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34342 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34343 #   define JITTER_ARGF0 JITTER_ARGP0
34344 
34345 
34346 #if defined (JITTER_PROFILE_SAMPLE)
34347   JITTER_PROFILE_SAMPLE_UPDATE
34348      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34349       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34350   /* Force the compiler not move sample-profiling instrumentation
34351      beyond this point; this way the actual user code is timed.
34352      This is still not perfect, as residuals are materialised before
34353      we arrive here, but should be adequate at least for slow VM
34354      instructions. */
34355   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34356 #endif
34357 #if defined (JITTER_PROFILE_COUNT)
34358   /* Notice that, differently from the code above, this
34359      instrumentation code *can* be reordered freely: as long as a
34360      VM instruction is counted, the count increment can be placed
34361      anyehere.  Let GCC move this code and possibly achieve better
34362      throughput by exploiting instruction-level parallelism and
34363      therefore approximate more closely a non-profiled build. */
34364   JITTER_PROFILE_COUNT_UPDATE
34365      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34366       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34367 #endif
34368 
34369 /* User-specified code, instruction-beginning-c part: beginning. */
34370 
34371 /* User-specified code, instruction-beginning-c part: end */
34372 
34373 
34374     /* User code for pushf/nR . */
34375 #line 1613 "../../libpoke/pvm.jitter"
34376 
34377     jitter_state_runtime.env
34378        = pvm_env_push_frame (jitter_state_runtime.env,
34379                              JITTER_ARGN0);
34380 
34381     /* End of the user code for pushf/nR . */
34382 
34383 /* User-specified code, instruction-end-c part: beginning. */
34384 
34385 /* User-specified code, instruction-end-c part: end */
34386 
34387     /* Undefine the pushf/nR argument macros so they can't be used
34388        by mistake in the instruction body coming next. */
34389 #   undef JITTER_SLOW_REGISTER_OFFSET0
34390 #   undef JITTER_ARG0
34391 #   undef JITTER_ARGN0
34392 #   undef JITTER_ARGU0
34393 #   undef JITTER_ARGP0
34394 #   undef JITTER_ARGF0
34395 
34396 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34397 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34398 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34399 
34400   }
34401  JITTER_INSTRUCTION_EPILOG_(pushf/nR, pushf__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34402 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34403 
34404   JITTER_INSTRUCTION_PROLOG_(pushhi/nR, pushhi__nR, cold)
34405   {
34406     /* This specialized instruction is not a replacement. */
34407 #   undef JITTER_BRANCH_FAST
34408 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34409 #   undef JITTER_BRANCH_FAST_IF_ZERO
34410 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34411 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34412 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34413 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34414 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34415 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34416 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34417 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34418 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34419 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34420 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34421 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34422 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34423 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34424 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34425 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34426 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34427 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34428 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34429 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34430 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34431 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34432 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34433 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34434 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34435 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34436 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34437 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34438 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34439 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34440 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34441 #   undef JITTER_BRANCH_FAST_IF_AND
34442 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34443 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34444 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34445 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34446 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34447 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34448 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34449 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34450 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34451 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34452 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34453 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34454 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34455 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34456 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34457 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34458 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34459 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34460 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34461 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34462 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34463 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34464 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34465 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34466 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34467 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34468 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34469 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34470 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34471 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       237
34472 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushhi/nR
34473 
34474 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushhi__nR
34475 
34476   /* The residual arity for this instruction does not depend on fast labels. */
34477   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
34478 
34479     /* The 0th argument is a residual literal. */
34480 #if defined(JITTER_DISPATCH_NO_THREADING)
34481 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
34482     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
34483 #elif defined (JITTER_REPLICATE)
34484 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
34485 #else
34486 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
34487 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
34488 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34489 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34490 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34491 #   define JITTER_ARGF0 JITTER_ARGP0
34492 
34493 
34494 #if defined (JITTER_PROFILE_SAMPLE)
34495   JITTER_PROFILE_SAMPLE_UPDATE
34496      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34497       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34498   /* Force the compiler not move sample-profiling instrumentation
34499      beyond this point; this way the actual user code is timed.
34500      This is still not perfect, as residuals are materialised before
34501      we arrive here, but should be adequate at least for slow VM
34502      instructions. */
34503   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34504 #endif
34505 #if defined (JITTER_PROFILE_COUNT)
34506   /* Notice that, differently from the code above, this
34507      instrumentation code *can* be reordered freely: as long as a
34508      VM instruction is counted, the count increment can be placed
34509      anyehere.  Let GCC move this code and possibly achieve better
34510      throughput by exploiting instruction-level parallelism and
34511      therefore approximate more closely a non-profiled build. */
34512   JITTER_PROFILE_COUNT_UPDATE
34513      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34514       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34515 #endif
34516 
34517 /* User-specified code, instruction-beginning-c part: beginning. */
34518 
34519 /* User-specified code, instruction-beginning-c part: end */
34520 
34521 
34522     /* User code for pushhi/nR . */
34523 #line 2127 "../../libpoke/pvm.jitter"
34524 
34525      jitter_state_runtime.push_hi
34526        = JITTER_ARGN0;
34527 
34528     /* End of the user code for pushhi/nR . */
34529 
34530 /* User-specified code, instruction-end-c part: beginning. */
34531 
34532 /* User-specified code, instruction-end-c part: end */
34533 
34534     /* Undefine the pushhi/nR argument macros so they can't be used
34535        by mistake in the instruction body coming next. */
34536 #   undef JITTER_SLOW_REGISTER_OFFSET0
34537 #   undef JITTER_ARG0
34538 #   undef JITTER_ARGN0
34539 #   undef JITTER_ARGU0
34540 #   undef JITTER_ARGP0
34541 #   undef JITTER_ARGF0
34542 
34543 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34544 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34545 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34546 
34547   }
34548  JITTER_INSTRUCTION_EPILOG_(pushhi/nR, pushhi__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34549 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34550 
34551   JITTER_INSTRUCTION_PROLOG_(pushhi/lR, pushhi__lR, hot)
34552   {
34553     /* This specialized instruction is not a replacement. */
34554 #   undef JITTER_BRANCH_FAST
34555 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34556 #   undef JITTER_BRANCH_FAST_IF_ZERO
34557 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34558 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34559 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34560 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34561 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34562 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34563 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34564 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34565 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34566 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34567 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34568 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34569 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34570 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34571 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34572 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34573 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34574 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34575 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34576 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34577 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34578 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34579 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34580 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34581 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34582 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34583 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34584 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34585 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34586 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34587 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34588 #   undef JITTER_BRANCH_FAST_IF_AND
34589 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34590 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34591 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34592 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34593 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34594 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34595 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34596 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34597 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34598 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34599 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34600 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34601 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34602 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34603 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34604 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34605 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34606 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34607 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34608 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34609 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34610 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34611 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34612 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34613 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34614 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34615 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34616 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34617 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34618 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       238
34619 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushhi/lR
34620 
34621 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushhi__lR
34622 
34623   /* The residual arity for this instruction does not depend on fast labels. */
34624   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
34625 
34626     /* The 0th argument is a residual label. */
34627 #if defined(JITTER_DISPATCH_NO_THREADING)
34628 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
34629     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
34630 #elif defined (JITTER_REPLICATE)
34631 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
34632 #else
34633 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
34634 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
34635 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34636 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34637 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34638 #   define JITTER_ARGF0 JITTER_ARGP0
34639 
34640 
34641 #if defined (JITTER_PROFILE_SAMPLE)
34642   JITTER_PROFILE_SAMPLE_UPDATE
34643      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34644       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34645   /* Force the compiler not move sample-profiling instrumentation
34646      beyond this point; this way the actual user code is timed.
34647      This is still not perfect, as residuals are materialised before
34648      we arrive here, but should be adequate at least for slow VM
34649      instructions. */
34650   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34651 #endif
34652 #if defined (JITTER_PROFILE_COUNT)
34653   /* Notice that, differently from the code above, this
34654      instrumentation code *can* be reordered freely: as long as a
34655      VM instruction is counted, the count increment can be placed
34656      anyehere.  Let GCC move this code and possibly achieve better
34657      throughput by exploiting instruction-level parallelism and
34658      therefore approximate more closely a non-profiled build. */
34659   JITTER_PROFILE_COUNT_UPDATE
34660      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34661       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34662 #endif
34663 
34664 /* User-specified code, instruction-beginning-c part: beginning. */
34665 
34666 /* User-specified code, instruction-beginning-c part: end */
34667 
34668 
34669     /* User code for pushhi/lR . */
34670 #line 2127 "../../libpoke/pvm.jitter"
34671 
34672      jitter_state_runtime.push_hi
34673        = JITTER_ARGN0;
34674 
34675     /* End of the user code for pushhi/lR . */
34676 
34677 /* User-specified code, instruction-end-c part: beginning. */
34678 
34679 /* User-specified code, instruction-end-c part: end */
34680 
34681     /* Undefine the pushhi/lR argument macros so they can't be used
34682        by mistake in the instruction body coming next. */
34683 #   undef JITTER_SLOW_REGISTER_OFFSET0
34684 #   undef JITTER_ARG0
34685 #   undef JITTER_ARGN0
34686 #   undef JITTER_ARGU0
34687 #   undef JITTER_ARGP0
34688 #   undef JITTER_ARGF0
34689 
34690 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34691 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34692 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34693 
34694   }
34695  JITTER_INSTRUCTION_EPILOG_(pushhi/lR, pushhi__lR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34696 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34697 
34698   JITTER_INSTRUCTION_PROLOG_(pushios, pushios, hot)
34699   {
34700     /* This specialized instruction is not a replacement. */
34701 #   undef JITTER_BRANCH_FAST
34702 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34703 #   undef JITTER_BRANCH_FAST_IF_ZERO
34704 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34705 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34706 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34707 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34708 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34709 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34710 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34711 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34712 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34713 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34714 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34715 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34716 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34717 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34718 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34719 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34720 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34721 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34722 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34723 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34724 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34725 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34726 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34727 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34728 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34729 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34730 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34731 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34732 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34733 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34734 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34735 #   undef JITTER_BRANCH_FAST_IF_AND
34736 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34737 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34738 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34739 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34740 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34741 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34742 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34743 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34744 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34745 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34746 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34747 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34748 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34749 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34750 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34751 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34752 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34753 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34754 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34755 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34756 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34757 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34758 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34759 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34760 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34761 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34762 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34763 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34764 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34765 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       239
34766 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushios
34767 
34768 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushios
34769 
34770   /* The residual arity for this instruction does not depend on fast labels. */
34771   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
34772 
34773 
34774 #if defined (JITTER_PROFILE_SAMPLE)
34775   JITTER_PROFILE_SAMPLE_UPDATE
34776      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34777       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34778   /* Force the compiler not move sample-profiling instrumentation
34779      beyond this point; this way the actual user code is timed.
34780      This is still not perfect, as residuals are materialised before
34781      we arrive here, but should be adequate at least for slow VM
34782      instructions. */
34783   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34784 #endif
34785 #if defined (JITTER_PROFILE_COUNT)
34786   /* Notice that, differently from the code above, this
34787      instrumentation code *can* be reordered freely: as long as a
34788      VM instruction is counted, the count increment can be placed
34789      anyehere.  Let GCC move this code and possibly achieve better
34790      throughput by exploiting instruction-level parallelism and
34791      therefore approximate more closely a non-profiled build. */
34792   JITTER_PROFILE_COUNT_UPDATE
34793      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34794       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34795 #endif
34796 
34797 /* User-specified code, instruction-beginning-c part: beginning. */
34798 
34799 /* User-specified code, instruction-beginning-c part: end */
34800 
34801 
34802     /* User code for pushios . */
34803 #line 1433 "../../libpoke/pvm.jitter"
34804 
34805     ios cur_io = ios_cur ();
34806 
34807     if (cur_io == NULL)
34808        PVM_RAISE_DFL (PVM_E_NO_IOS);
34809     JITTER_PUSH_STACK (PVM_MAKE_INT (ios_get_id (cur_io), 32));
34810 
34811     /* End of the user code for pushios . */
34812 
34813 /* User-specified code, instruction-end-c part: beginning. */
34814 
34815 /* User-specified code, instruction-end-c part: end */
34816 
34817     /* Undefine the pushios argument macros so they can't be used
34818        by mistake in the instruction body coming next. */
34819 
34820 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34821 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34822 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34823 
34824   }
34825  JITTER_INSTRUCTION_EPILOG_(pushios, pushios, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34826 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34827 
34828   JITTER_INSTRUCTION_PROLOG_(pushlo/nR, pushlo__nR, cold)
34829   {
34830     /* This specialized instruction is not a replacement. */
34831 #   undef JITTER_BRANCH_FAST
34832 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34833 #   undef JITTER_BRANCH_FAST_IF_ZERO
34834 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34835 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34836 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34837 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34838 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34839 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34840 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34841 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34842 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34843 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34844 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34845 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34846 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34847 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34848 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34849 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34850 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34851 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34852 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34853 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34854 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34855 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34856 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34857 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34858 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34859 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34860 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34861 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34862 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34863 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34864 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34865 #   undef JITTER_BRANCH_FAST_IF_AND
34866 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34867 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34868 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34869 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34870 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34871 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34872 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34873 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34874 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34875 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34876 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34877 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34878 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34879 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34880 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34881 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34882 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34883 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34884 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34885 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34886 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34887 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34888 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34889 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34890 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34891 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34892 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34893 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34894 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34895 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       240
34896 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushlo/nR
34897 
34898 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushlo__nR
34899 
34900   /* The residual arity for this instruction does not depend on fast labels. */
34901   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
34902 
34903     /* The 0th argument is a residual literal. */
34904 #if defined(JITTER_DISPATCH_NO_THREADING)
34905 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
34906     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
34907 #elif defined (JITTER_REPLICATE)
34908 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
34909 #else
34910 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
34911 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
34912 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34913 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34914 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34915 #   define JITTER_ARGF0 JITTER_ARGP0
34916 
34917 
34918 #if defined (JITTER_PROFILE_SAMPLE)
34919   JITTER_PROFILE_SAMPLE_UPDATE
34920      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34921       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34922   /* Force the compiler not move sample-profiling instrumentation
34923      beyond this point; this way the actual user code is timed.
34924      This is still not perfect, as residuals are materialised before
34925      we arrive here, but should be adequate at least for slow VM
34926      instructions. */
34927   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34928 #endif
34929 #if defined (JITTER_PROFILE_COUNT)
34930   /* Notice that, differently from the code above, this
34931      instrumentation code *can* be reordered freely: as long as a
34932      VM instruction is counted, the count increment can be placed
34933      anyehere.  Let GCC move this code and possibly achieve better
34934      throughput by exploiting instruction-level parallelism and
34935      therefore approximate more closely a non-profiled build. */
34936   JITTER_PROFILE_COUNT_UPDATE
34937      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34938       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34939 #endif
34940 
34941 /* User-specified code, instruction-beginning-c part: beginning. */
34942 
34943 /* User-specified code, instruction-beginning-c part: end */
34944 
34945 
34946     /* User code for pushlo/nR . */
34947 #line 2143 "../../libpoke/pvm.jitter"
34948 
34949      pvm_val k
34950        = ((pvm_val) jitter_state_runtime.push_hi << 32)
34951          | JITTER_ARGN0;
34952      JITTER_PUSH_STACK (k);
34953 
34954     /* End of the user code for pushlo/nR . */
34955 
34956 /* User-specified code, instruction-end-c part: beginning. */
34957 
34958 /* User-specified code, instruction-end-c part: end */
34959 
34960     /* Undefine the pushlo/nR argument macros so they can't be used
34961        by mistake in the instruction body coming next. */
34962 #   undef JITTER_SLOW_REGISTER_OFFSET0
34963 #   undef JITTER_ARG0
34964 #   undef JITTER_ARGN0
34965 #   undef JITTER_ARGU0
34966 #   undef JITTER_ARGP0
34967 #   undef JITTER_ARGF0
34968 
34969 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34970 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34971 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34972 
34973   }
34974  JITTER_INSTRUCTION_EPILOG_(pushlo/nR, pushlo__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34975 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34976 
34977   JITTER_INSTRUCTION_PROLOG_(pushlo/lR, pushlo__lR, hot)
34978   {
34979     /* This specialized instruction is not a replacement. */
34980 #   undef JITTER_BRANCH_FAST
34981 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34982 #   undef JITTER_BRANCH_FAST_IF_ZERO
34983 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34984 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34985 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34986 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34987 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34988 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34989 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34990 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34991 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34992 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34993 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34994 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34995 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34996 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34997 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34998 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34999 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35000 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35001 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35002 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35003 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35004 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35005 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35006 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35007 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35008 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35009 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35010 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35011 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35012 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35013 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35014 #   undef JITTER_BRANCH_FAST_IF_AND
35015 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35016 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35017 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35018 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35019 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35020 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35021 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35022 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35023 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35024 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35025 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35026 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35027 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35028 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35029 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35030 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35031 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35032 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35033 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35034 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35035 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35036 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35037 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35038 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35039 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35040 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35041 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35042 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35043 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35044 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       241
35045 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushlo/lR
35046 
35047 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushlo__lR
35048 
35049   /* The residual arity for this instruction does not depend on fast labels. */
35050   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
35051 
35052     /* The 0th argument is a residual label. */
35053 #if defined(JITTER_DISPATCH_NO_THREADING)
35054 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
35055     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
35056 #elif defined (JITTER_REPLICATE)
35057 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
35058 #else
35059 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
35060 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
35061 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
35062 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
35063 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
35064 #   define JITTER_ARGF0 JITTER_ARGP0
35065 
35066 
35067 #if defined (JITTER_PROFILE_SAMPLE)
35068   JITTER_PROFILE_SAMPLE_UPDATE
35069      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35070       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35071   /* Force the compiler not move sample-profiling instrumentation
35072      beyond this point; this way the actual user code is timed.
35073      This is still not perfect, as residuals are materialised before
35074      we arrive here, but should be adequate at least for slow VM
35075      instructions. */
35076   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35077 #endif
35078 #if defined (JITTER_PROFILE_COUNT)
35079   /* Notice that, differently from the code above, this
35080      instrumentation code *can* be reordered freely: as long as a
35081      VM instruction is counted, the count increment can be placed
35082      anyehere.  Let GCC move this code and possibly achieve better
35083      throughput by exploiting instruction-level parallelism and
35084      therefore approximate more closely a non-profiled build. */
35085   JITTER_PROFILE_COUNT_UPDATE
35086      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35087       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35088 #endif
35089 
35090 /* User-specified code, instruction-beginning-c part: beginning. */
35091 
35092 /* User-specified code, instruction-beginning-c part: end */
35093 
35094 
35095     /* User code for pushlo/lR . */
35096 #line 2143 "../../libpoke/pvm.jitter"
35097 
35098      pvm_val k
35099        = ((pvm_val) jitter_state_runtime.push_hi << 32)
35100          | JITTER_ARGN0;
35101      JITTER_PUSH_STACK (k);
35102 
35103     /* End of the user code for pushlo/lR . */
35104 
35105 /* User-specified code, instruction-end-c part: beginning. */
35106 
35107 /* User-specified code, instruction-end-c part: end */
35108 
35109     /* Undefine the pushlo/lR argument macros so they can't be used
35110        by mistake in the instruction body coming next. */
35111 #   undef JITTER_SLOW_REGISTER_OFFSET0
35112 #   undef JITTER_ARG0
35113 #   undef JITTER_ARGN0
35114 #   undef JITTER_ARGU0
35115 #   undef JITTER_ARGP0
35116 #   undef JITTER_ARGF0
35117 
35118 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35119 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35120 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35121 
35122   }
35123  JITTER_INSTRUCTION_EPILOG_(pushlo/lR, pushlo__lR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35124 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35125 
35126   JITTER_INSTRUCTION_PROLOG_(pushoac, pushoac, hot)
35127   {
35128     /* This specialized instruction is not a replacement. */
35129 #   undef JITTER_BRANCH_FAST
35130 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35131 #   undef JITTER_BRANCH_FAST_IF_ZERO
35132 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35133 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35134 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35135 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35136 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35137 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35138 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35139 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35140 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35141 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35142 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35143 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35144 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35145 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35146 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35147 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35148 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35149 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35150 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35151 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35152 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35153 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35154 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35155 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35156 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35157 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35158 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35159 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35160 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35161 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35162 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35163 #   undef JITTER_BRANCH_FAST_IF_AND
35164 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35165 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35166 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35167 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35168 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35169 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35170 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35171 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35172 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35173 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35174 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35175 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35176 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35177 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35178 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35179 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35180 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35181 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35182 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35183 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35184 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35185 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35186 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35187 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35188 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35189 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35190 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35191 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35192 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35193 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       242
35194 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushoac
35195 
35196 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushoac
35197 
35198   /* The residual arity for this instruction does not depend on fast labels. */
35199   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35200 
35201 
35202 #if defined (JITTER_PROFILE_SAMPLE)
35203   JITTER_PROFILE_SAMPLE_UPDATE
35204      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35205       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35206   /* Force the compiler not move sample-profiling instrumentation
35207      beyond this point; this way the actual user code is timed.
35208      This is still not perfect, as residuals are materialised before
35209      we arrive here, but should be adequate at least for slow VM
35210      instructions. */
35211   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35212 #endif
35213 #if defined (JITTER_PROFILE_COUNT)
35214   /* Notice that, differently from the code above, this
35215      instrumentation code *can* be reordered freely: as long as a
35216      VM instruction is counted, the count increment can be placed
35217      anyehere.  Let GCC move this code and possibly achieve better
35218      throughput by exploiting instruction-level parallelism and
35219      therefore approximate more closely a non-profiled build. */
35220   JITTER_PROFILE_COUNT_UPDATE
35221      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35222       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35223 #endif
35224 
35225 /* User-specified code, instruction-beginning-c part: beginning. */
35226 
35227 /* User-specified code, instruction-beginning-c part: end */
35228 
35229 
35230     /* User code for pushoac . */
35231 #line 1171 "../../libpoke/pvm.jitter"
35232 
35233     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
35234     int oacutoff = pvm_oacutoff (vm);
35235 
35236     JITTER_PUSH_STACK (PVM_MAKE_INT (oacutoff, 32));
35237 
35238     /* End of the user code for pushoac . */
35239 
35240 /* User-specified code, instruction-end-c part: beginning. */
35241 
35242 /* User-specified code, instruction-end-c part: end */
35243 
35244     /* Undefine the pushoac argument macros so they can't be used
35245        by mistake in the instruction body coming next. */
35246 
35247 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35248 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35249 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35250 
35251   }
35252  JITTER_INSTRUCTION_EPILOG_(pushoac, pushoac, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35253 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35254 
35255   JITTER_INSTRUCTION_PROLOG_(pushob, pushob, hot)
35256   {
35257     /* This specialized instruction is not a replacement. */
35258 #   undef JITTER_BRANCH_FAST
35259 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35260 #   undef JITTER_BRANCH_FAST_IF_ZERO
35261 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35262 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35263 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35264 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35265 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35266 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35267 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35268 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35269 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35270 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35271 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35272 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35273 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35274 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35275 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35276 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35277 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35278 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35279 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35280 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35281 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35282 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35283 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35284 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35285 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35286 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35287 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35288 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35289 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35290 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35291 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35292 #   undef JITTER_BRANCH_FAST_IF_AND
35293 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35294 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35295 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35296 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35297 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35298 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35299 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35300 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35301 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35302 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35303 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35304 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35305 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35306 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35307 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35308 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35309 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35310 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35311 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35312 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35313 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35314 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35315 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35316 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35317 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35318 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35319 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35320 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35321 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35322 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       243
35323 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushob
35324 
35325 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushob
35326 
35327   /* The residual arity for this instruction does not depend on fast labels. */
35328   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35329 
35330 
35331 #if defined (JITTER_PROFILE_SAMPLE)
35332   JITTER_PROFILE_SAMPLE_UPDATE
35333      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35334       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35335   /* Force the compiler not move sample-profiling instrumentation
35336      beyond this point; this way the actual user code is timed.
35337      This is still not perfect, as residuals are materialised before
35338      we arrive here, but should be adequate at least for slow VM
35339      instructions. */
35340   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35341 #endif
35342 #if defined (JITTER_PROFILE_COUNT)
35343   /* Notice that, differently from the code above, this
35344      instrumentation code *can* be reordered freely: as long as a
35345      VM instruction is counted, the count increment can be placed
35346      anyehere.  Let GCC move this code and possibly achieve better
35347      throughput by exploiting instruction-level parallelism and
35348      therefore approximate more closely a non-profiled build. */
35349   JITTER_PROFILE_COUNT_UPDATE
35350      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35351       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35352 #endif
35353 
35354 /* User-specified code, instruction-beginning-c part: beginning. */
35355 
35356 /* User-specified code, instruction-beginning-c part: end */
35357 
35358 
35359     /* User code for pushob . */
35360 #line 963 "../../libpoke/pvm.jitter"
35361 
35362     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
35363     int obase = pvm_obase (vm);
35364 
35365     JITTER_PUSH_STACK (PVM_MAKE_INT (obase, 32));
35366 
35367     /* End of the user code for pushob . */
35368 
35369 /* User-specified code, instruction-end-c part: beginning. */
35370 
35371 /* User-specified code, instruction-end-c part: end */
35372 
35373     /* Undefine the pushob argument macros so they can't be used
35374        by mistake in the instruction body coming next. */
35375 
35376 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35377 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35378 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35379 
35380   }
35381  JITTER_INSTRUCTION_EPILOG_(pushob, pushob, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35382 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35383 
35384   JITTER_INSTRUCTION_PROLOG_(pushobc, pushobc, hot)
35385   {
35386     /* This specialized instruction is not a replacement. */
35387 #   undef JITTER_BRANCH_FAST
35388 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35389 #   undef JITTER_BRANCH_FAST_IF_ZERO
35390 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35391 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35392 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35393 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35394 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35395 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35396 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35397 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35398 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35399 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35400 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35401 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35402 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35403 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35404 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35405 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35406 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35407 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35408 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35409 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35410 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35411 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35412 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35413 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35414 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35415 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35416 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35417 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35418 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35419 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35420 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35421 #   undef JITTER_BRANCH_FAST_IF_AND
35422 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35423 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35424 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35425 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35426 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35427 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35428 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35429 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35430 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35431 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35432 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35433 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35434 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35435 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35436 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35437 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35438 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35439 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35440 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35441 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35442 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35443 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35444 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35445 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35446 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35447 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35448 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35449 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35450 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35451 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       244
35452 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushobc
35453 
35454 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushobc
35455 
35456   /* The residual arity for this instruction does not depend on fast labels. */
35457   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35458 
35459 
35460 #if defined (JITTER_PROFILE_SAMPLE)
35461   JITTER_PROFILE_SAMPLE_UPDATE
35462      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35463       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35464   /* Force the compiler not move sample-profiling instrumentation
35465      beyond this point; this way the actual user code is timed.
35466      This is still not perfect, as residuals are materialised before
35467      we arrive here, but should be adequate at least for slow VM
35468      instructions. */
35469   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35470 #endif
35471 #if defined (JITTER_PROFILE_COUNT)
35472   /* Notice that, differently from the code above, this
35473      instrumentation code *can* be reordered freely: as long as a
35474      VM instruction is counted, the count increment can be placed
35475      anyehere.  Let GCC move this code and possibly achieve better
35476      throughput by exploiting instruction-level parallelism and
35477      therefore approximate more closely a non-profiled build. */
35478   JITTER_PROFILE_COUNT_UPDATE
35479      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35480       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35481 #endif
35482 
35483 /* User-specified code, instruction-beginning-c part: beginning. */
35484 
35485 /* User-specified code, instruction-beginning-c part: end */
35486 
35487 
35488     /* User code for pushobc . */
35489 #line 1283 "../../libpoke/pvm.jitter"
35490 
35491     struct pk_color color = pk_term_get_bgcolor ();
35492 
35493     JITTER_PUSH_STACK (PVM_MAKE_INT (color.red, 32));
35494     JITTER_PUSH_STACK (PVM_MAKE_INT (color.green, 32));
35495     JITTER_PUSH_STACK (PVM_MAKE_INT (color.blue, 32));
35496 
35497     /* End of the user code for pushobc . */
35498 
35499 /* User-specified code, instruction-end-c part: beginning. */
35500 
35501 /* User-specified code, instruction-end-c part: end */
35502 
35503     /* Undefine the pushobc argument macros so they can't be used
35504        by mistake in the instruction body coming next. */
35505 
35506 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35507 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35508 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35509 
35510   }
35511  JITTER_INSTRUCTION_EPILOG_(pushobc, pushobc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35512 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35513 
35514   JITTER_INSTRUCTION_PROLOG_(pushoc, pushoc, hot)
35515   {
35516     /* This specialized instruction is not a replacement. */
35517 #   undef JITTER_BRANCH_FAST
35518 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35519 #   undef JITTER_BRANCH_FAST_IF_ZERO
35520 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35521 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35522 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35523 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35524 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35525 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35526 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35527 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35528 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35529 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35530 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35531 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35532 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35533 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35534 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35535 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35536 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35537 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35538 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35539 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35540 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35541 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35542 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35543 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35544 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35545 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35546 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35547 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35548 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35549 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35550 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35551 #   undef JITTER_BRANCH_FAST_IF_AND
35552 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35553 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35554 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35555 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35556 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35557 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35558 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35559 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35560 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35561 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35562 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35563 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35564 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35565 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35566 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35567 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35568 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35569 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35570 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35571 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35572 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35573 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35574 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35575 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35576 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35577 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35578 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35579 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35580 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35581 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       245
35582 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushoc
35583 
35584 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushoc
35585 
35586   /* The residual arity for this instruction does not depend on fast labels. */
35587   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35588 
35589 
35590 #if defined (JITTER_PROFILE_SAMPLE)
35591   JITTER_PROFILE_SAMPLE_UPDATE
35592      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35593       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35594   /* Force the compiler not move sample-profiling instrumentation
35595      beyond this point; this way the actual user code is timed.
35596      This is still not perfect, as residuals are materialised before
35597      we arrive here, but should be adequate at least for slow VM
35598      instructions. */
35599   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35600 #endif
35601 #if defined (JITTER_PROFILE_COUNT)
35602   /* Notice that, differently from the code above, this
35603      instrumentation code *can* be reordered freely: as long as a
35604      VM instruction is counted, the count increment can be placed
35605      anyehere.  Let GCC move this code and possibly achieve better
35606      throughput by exploiting instruction-level parallelism and
35607      therefore approximate more closely a non-profiled build. */
35608   JITTER_PROFILE_COUNT_UPDATE
35609      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35610       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35611 #endif
35612 
35613 /* User-specified code, instruction-beginning-c part: beginning. */
35614 
35615 /* User-specified code, instruction-beginning-c part: end */
35616 
35617 
35618     /* User code for pushoc . */
35619 #line 1244 "../../libpoke/pvm.jitter"
35620 
35621     struct pk_color color = pk_term_get_color ();
35622 
35623     JITTER_PUSH_STACK (PVM_MAKE_INT (color.red, 32));
35624     JITTER_PUSH_STACK (PVM_MAKE_INT (color.green, 32));
35625     JITTER_PUSH_STACK (PVM_MAKE_INT (color.blue, 32));
35626 
35627     /* End of the user code for pushoc . */
35628 
35629 /* User-specified code, instruction-end-c part: beginning. */
35630 
35631 /* User-specified code, instruction-end-c part: end */
35632 
35633     /* Undefine the pushoc argument macros so they can't be used
35634        by mistake in the instruction body coming next. */
35635 
35636 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35637 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35638 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35639 
35640   }
35641  JITTER_INSTRUCTION_EPILOG_(pushoc, pushoc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35642 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35643 
35644   JITTER_INSTRUCTION_PROLOG_(pushod, pushod, hot)
35645   {
35646     /* This specialized instruction is not a replacement. */
35647 #   undef JITTER_BRANCH_FAST
35648 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35649 #   undef JITTER_BRANCH_FAST_IF_ZERO
35650 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35651 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35652 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35653 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35654 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35655 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35656 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35657 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35658 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35659 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35660 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35661 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35662 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35663 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35664 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35665 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35666 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35667 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35668 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35669 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35670 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35671 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35672 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35673 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35674 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35675 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35676 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35677 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35678 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35679 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35680 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35681 #   undef JITTER_BRANCH_FAST_IF_AND
35682 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35683 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35684 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35685 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35686 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35687 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35688 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35689 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35690 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35691 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35692 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35693 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35694 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35695 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35696 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35697 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35698 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35699 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35700 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35701 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35702 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35703 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35704 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35705 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35706 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35707 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35708 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35709 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35710 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35711 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       246
35712 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushod
35713 
35714 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushod
35715 
35716   /* The residual arity for this instruction does not depend on fast labels. */
35717   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35718 
35719 
35720 #if defined (JITTER_PROFILE_SAMPLE)
35721   JITTER_PROFILE_SAMPLE_UPDATE
35722      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35723       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35724   /* Force the compiler not move sample-profiling instrumentation
35725      beyond this point; this way the actual user code is timed.
35726      This is still not perfect, as residuals are materialised before
35727      we arrive here, but should be adequate at least for slow VM
35728      instructions. */
35729   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35730 #endif
35731 #if defined (JITTER_PROFILE_COUNT)
35732   /* Notice that, differently from the code above, this
35733      instrumentation code *can* be reordered freely: as long as a
35734      VM instruction is counted, the count increment can be placed
35735      anyehere.  Let GCC move this code and possibly achieve better
35736      throughput by exploiting instruction-level parallelism and
35737      therefore approximate more closely a non-profiled build. */
35738   JITTER_PROFILE_COUNT_UPDATE
35739      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35740       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35741 #endif
35742 
35743 /* User-specified code, instruction-beginning-c part: beginning. */
35744 
35745 /* User-specified code, instruction-beginning-c part: end */
35746 
35747 
35748     /* User code for pushod . */
35749 #line 1133 "../../libpoke/pvm.jitter"
35750 
35751     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
35752     int odepth = pvm_odepth (vm);
35753 
35754     JITTER_PUSH_STACK (PVM_MAKE_INT (odepth, 32));
35755 
35756     /* End of the user code for pushod . */
35757 
35758 /* User-specified code, instruction-end-c part: beginning. */
35759 
35760 /* User-specified code, instruction-end-c part: end */
35761 
35762     /* Undefine the pushod argument macros so they can't be used
35763        by mistake in the instruction body coming next. */
35764 
35765 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35766 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35767 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35768 
35769   }
35770  JITTER_INSTRUCTION_EPILOG_(pushod, pushod, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35771 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35772 
35773   JITTER_INSTRUCTION_PROLOG_(pushoi, pushoi, hot)
35774   {
35775     /* This specialized instruction is not a replacement. */
35776 #   undef JITTER_BRANCH_FAST
35777 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35778 #   undef JITTER_BRANCH_FAST_IF_ZERO
35779 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35780 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35781 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35782 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35783 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35784 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35785 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35786 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35787 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35788 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35789 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35790 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35791 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35792 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35793 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35794 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35795 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35796 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35797 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35798 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35799 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35800 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35801 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35802 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35803 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35804 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35805 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35806 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35807 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35808 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35809 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35810 #   undef JITTER_BRANCH_FAST_IF_AND
35811 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35812 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35813 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35814 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35815 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35816 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35817 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35818 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35819 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35820 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35821 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35822 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35823 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35824 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35825 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35826 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35827 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35828 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35829 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35830 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35831 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35832 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35833 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35834 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35835 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35836 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35837 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35838 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35839 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35840 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       247
35841 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushoi
35842 
35843 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushoi
35844 
35845   /* The residual arity for this instruction does not depend on fast labels. */
35846   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35847 
35848 
35849 #if defined (JITTER_PROFILE_SAMPLE)
35850   JITTER_PROFILE_SAMPLE_UPDATE
35851      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35852       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35853   /* Force the compiler not move sample-profiling instrumentation
35854      beyond this point; this way the actual user code is timed.
35855      This is still not perfect, as residuals are materialised before
35856      we arrive here, but should be adequate at least for slow VM
35857      instructions. */
35858   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35859 #endif
35860 #if defined (JITTER_PROFILE_COUNT)
35861   /* Notice that, differently from the code above, this
35862      instrumentation code *can* be reordered freely: as long as a
35863      VM instruction is counted, the count increment can be placed
35864      anyehere.  Let GCC move this code and possibly achieve better
35865      throughput by exploiting instruction-level parallelism and
35866      therefore approximate more closely a non-profiled build. */
35867   JITTER_PROFILE_COUNT_UPDATE
35868      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35869       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35870 #endif
35871 
35872 /* User-specified code, instruction-beginning-c part: beginning. */
35873 
35874 /* User-specified code, instruction-beginning-c part: end */
35875 
35876 
35877     /* User code for pushoi . */
35878 #line 1094 "../../libpoke/pvm.jitter"
35879 
35880     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
35881     int oindent = pvm_oindent (vm);
35882 
35883     JITTER_PUSH_STACK (PVM_MAKE_INT (oindent, 32));
35884 
35885     /* End of the user code for pushoi . */
35886 
35887 /* User-specified code, instruction-end-c part: beginning. */
35888 
35889 /* User-specified code, instruction-end-c part: end */
35890 
35891     /* Undefine the pushoi argument macros so they can't be used
35892        by mistake in the instruction body coming next. */
35893 
35894 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35895 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35896 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35897 
35898   }
35899  JITTER_INSTRUCTION_EPILOG_(pushoi, pushoi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35900 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35901 
35902   JITTER_INSTRUCTION_PROLOG_(pushom, pushom, hot)
35903   {
35904     /* This specialized instruction is not a replacement. */
35905 #   undef JITTER_BRANCH_FAST
35906 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35907 #   undef JITTER_BRANCH_FAST_IF_ZERO
35908 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35909 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35910 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35911 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35912 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35913 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35914 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35915 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35916 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35917 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35918 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35919 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35920 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35921 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35922 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35923 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35924 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35925 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35926 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35927 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35928 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35929 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35930 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35931 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35932 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35933 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35934 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35935 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35936 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35937 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35938 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35939 #   undef JITTER_BRANCH_FAST_IF_AND
35940 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35941 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35942 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35943 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35944 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35945 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35946 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35947 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35948 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35949 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35950 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35951 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35952 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35953 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35954 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35955 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35956 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35957 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35958 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35959 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35960 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35961 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35962 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35963 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35964 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35965 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35966 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35967 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35968 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35969 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       248
35970 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushom
35971 
35972 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushom
35973 
35974   /* The residual arity for this instruction does not depend on fast labels. */
35975   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35976 
35977 
35978 #if defined (JITTER_PROFILE_SAMPLE)
35979   JITTER_PROFILE_SAMPLE_UPDATE
35980      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35981       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35982   /* Force the compiler not move sample-profiling instrumentation
35983      beyond this point; this way the actual user code is timed.
35984      This is still not perfect, as residuals are materialised before
35985      we arrive here, but should be adequate at least for slow VM
35986      instructions. */
35987   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35988 #endif
35989 #if defined (JITTER_PROFILE_COUNT)
35990   /* Notice that, differently from the code above, this
35991      instrumentation code *can* be reordered freely: as long as a
35992      VM instruction is counted, the count increment can be placed
35993      anyehere.  Let GCC move this code and possibly achieve better
35994      throughput by exploiting instruction-level parallelism and
35995      therefore approximate more closely a non-profiled build. */
35996   JITTER_PROFILE_COUNT_UPDATE
35997      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35998       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35999 #endif
36000 
36001 /* User-specified code, instruction-beginning-c part: beginning. */
36002 
36003 /* User-specified code, instruction-beginning-c part: end */
36004 
36005 
36006     /* User code for pushom . */
36007 #line 1009 "../../libpoke/pvm.jitter"
36008 
36009     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
36010     int omode = pvm_omode (vm);
36011 
36012     JITTER_PUSH_STACK (PVM_MAKE_INT (omode, 32));
36013 
36014     /* End of the user code for pushom . */
36015 
36016 /* User-specified code, instruction-end-c part: beginning. */
36017 
36018 /* User-specified code, instruction-end-c part: end */
36019 
36020     /* Undefine the pushom argument macros so they can't be used
36021        by mistake in the instruction body coming next. */
36022 
36023 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36024 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36025 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36026 
36027   }
36028  JITTER_INSTRUCTION_EPILOG_(pushom, pushom, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36029 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36030 
36031   JITTER_INSTRUCTION_PROLOG_(pushoo, pushoo, hot)
36032   {
36033     /* This specialized instruction is not a replacement. */
36034 #   undef JITTER_BRANCH_FAST
36035 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36036 #   undef JITTER_BRANCH_FAST_IF_ZERO
36037 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36038 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36039 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36040 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36041 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36042 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36043 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36044 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36045 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36046 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36047 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36048 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36049 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36050 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36051 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36052 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36053 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36054 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36055 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36056 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36057 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36058 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36059 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36060 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36061 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36062 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36063 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36064 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36065 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36066 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36067 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36068 #   undef JITTER_BRANCH_FAST_IF_AND
36069 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36070 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36071 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36072 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36073 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36074 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36075 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36076 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36077 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36078 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36079 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36080 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36081 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36082 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36083 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36084 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36085 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36086 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36087 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36088 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36089 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36090 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36091 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36092 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36093 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36094 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36095 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36096 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36097 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36098 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       249
36099 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushoo
36100 
36101 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushoo
36102 
36103   /* The residual arity for this instruction does not depend on fast labels. */
36104   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36105 
36106 
36107 #if defined (JITTER_PROFILE_SAMPLE)
36108   JITTER_PROFILE_SAMPLE_UPDATE
36109      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36110       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36111   /* Force the compiler not move sample-profiling instrumentation
36112      beyond this point; this way the actual user code is timed.
36113      This is still not perfect, as residuals are materialised before
36114      we arrive here, but should be adequate at least for slow VM
36115      instructions. */
36116   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36117 #endif
36118 #if defined (JITTER_PROFILE_COUNT)
36119   /* Notice that, differently from the code above, this
36120      instrumentation code *can* be reordered freely: as long as a
36121      VM instruction is counted, the count increment can be placed
36122      anyehere.  Let GCC move this code and possibly achieve better
36123      throughput by exploiting instruction-level parallelism and
36124      therefore approximate more closely a non-profiled build. */
36125   JITTER_PROFILE_COUNT_UPDATE
36126      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36127       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36128 #endif
36129 
36130 /* User-specified code, instruction-beginning-c part: beginning. */
36131 
36132 /* User-specified code, instruction-beginning-c part: end */
36133 
36134 
36135     /* User code for pushoo . */
36136 #line 1054 "../../libpoke/pvm.jitter"
36137 
36138     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
36139     int omaps = pvm_omaps (vm);
36140 
36141     JITTER_PUSH_STACK (PVM_MAKE_INT (omaps, 32));
36142 
36143     /* End of the user code for pushoo . */
36144 
36145 /* User-specified code, instruction-end-c part: beginning. */
36146 
36147 /* User-specified code, instruction-end-c part: end */
36148 
36149     /* Undefine the pushoo argument macros so they can't be used
36150        by mistake in the instruction body coming next. */
36151 
36152 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36153 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36154 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36155 
36156   }
36157  JITTER_INSTRUCTION_EPILOG_(pushoo, pushoo, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36158 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36159 
36160   JITTER_INSTRUCTION_PROLOG_(pushopp, pushopp, hot)
36161   {
36162     /* This specialized instruction is not a replacement. */
36163 #   undef JITTER_BRANCH_FAST
36164 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36165 #   undef JITTER_BRANCH_FAST_IF_ZERO
36166 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36167 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36168 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36169 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36170 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36171 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36172 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36173 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36174 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36175 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36176 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36177 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36178 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36179 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36180 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36181 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36182 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36183 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36184 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36185 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36186 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36187 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36188 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36189 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36190 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36191 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36192 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36193 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36194 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36195 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36196 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36197 #   undef JITTER_BRANCH_FAST_IF_AND
36198 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36199 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36200 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36201 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36202 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36203 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36204 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36205 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36206 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36207 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36208 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36209 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36210 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36211 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36212 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36213 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36214 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36215 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36216 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36217 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36218 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36219 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36220 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36221 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36222 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36223 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36224 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36225 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36226 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36227 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       250
36228 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushopp
36229 
36230 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushopp
36231 
36232   /* The residual arity for this instruction does not depend on fast labels. */
36233   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36234 
36235 
36236 #if defined (JITTER_PROFILE_SAMPLE)
36237   JITTER_PROFILE_SAMPLE_UPDATE
36238      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36239       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36240   /* Force the compiler not move sample-profiling instrumentation
36241      beyond this point; this way the actual user code is timed.
36242      This is still not perfect, as residuals are materialised before
36243      we arrive here, but should be adequate at least for slow VM
36244      instructions. */
36245   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36246 #endif
36247 #if defined (JITTER_PROFILE_COUNT)
36248   /* Notice that, differently from the code above, this
36249      instrumentation code *can* be reordered freely: as long as a
36250      VM instruction is counted, the count increment can be placed
36251      anyehere.  Let GCC move this code and possibly achieve better
36252      throughput by exploiting instruction-level parallelism and
36253      therefore approximate more closely a non-profiled build. */
36254   JITTER_PROFILE_COUNT_UPDATE
36255      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36256       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36257 #endif
36258 
36259 /* User-specified code, instruction-beginning-c part: beginning. */
36260 
36261 /* User-specified code, instruction-beginning-c part: end */
36262 
36263 
36264     /* User code for pushopp . */
36265 #line 1209 "../../libpoke/pvm.jitter"
36266 
36267     pvm vm = JITTER_STATE_BACKING_FIELD (vm);
36268     int pp = pvm_pretty_print (vm);
36269 
36270     JITTER_PUSH_STACK (PVM_MAKE_INT (pp, 32));
36271 
36272     /* End of the user code for pushopp . */
36273 
36274 /* User-specified code, instruction-end-c part: beginning. */
36275 
36276 /* User-specified code, instruction-end-c part: end */
36277 
36278     /* Undefine the pushopp argument macros so they can't be used
36279        by mistake in the instruction body coming next. */
36280 
36281 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36282 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36283 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36284 
36285   }
36286  JITTER_INSTRUCTION_EPILOG_(pushopp, pushopp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36287 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36288 
36289   JITTER_INSTRUCTION_PROLOG_(pushr/%rR, pushr___rrR, cold)
36290   {
36291     /* This specialized instruction is not a replacement. */
36292 #   undef JITTER_BRANCH_FAST
36293 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36294 #   undef JITTER_BRANCH_FAST_IF_ZERO
36295 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36296 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36297 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36298 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36299 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36300 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36301 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36302 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36303 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36304 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36305 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36306 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36307 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36308 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36309 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36310 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36311 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36312 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36313 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36314 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36315 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36316 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36317 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36318 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36319 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36320 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36321 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36322 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36323 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36324 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36325 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36326 #   undef JITTER_BRANCH_FAST_IF_AND
36327 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36328 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36329 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36330 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36331 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36332 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36333 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36334 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36335 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36336 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36337 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36338 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36339 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36340 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36341 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36342 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36343 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36344 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36345 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36346 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36347 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36348 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36349 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36350 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36351 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36352 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36353 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36354 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36355 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36356 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       251
36357 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushr/%rR
36358 
36359 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushr___rrR
36360 
36361   /* The residual arity for this instruction does not depend on fast labels. */
36362   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
36363 
36364     /* The 0th argument is a slow (therefore residual, passed as an offset)
36365         register. */
36366   /* Define a macro expanding to the slow register offset. */
36367 #if defined(JITTER_DISPATCH_NO_THREADING)
36368 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
36369 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
36370 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
36371 #else
36372 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
36373 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
36374   /* Define a macro expanding to an l-value for the VM register content. */
36375 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
36376 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36377 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36378 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36379 #   define JITTER_ARGF0 JITTER_ARGP0
36380 
36381 
36382 #if defined (JITTER_PROFILE_SAMPLE)
36383   JITTER_PROFILE_SAMPLE_UPDATE
36384      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36385       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36386   /* Force the compiler not move sample-profiling instrumentation
36387      beyond this point; this way the actual user code is timed.
36388      This is still not perfect, as residuals are materialised before
36389      we arrive here, but should be adequate at least for slow VM
36390      instructions. */
36391   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36392 #endif
36393 #if defined (JITTER_PROFILE_COUNT)
36394   /* Notice that, differently from the code above, this
36395      instrumentation code *can* be reordered freely: as long as a
36396      VM instruction is counted, the count increment can be placed
36397      anyehere.  Let GCC move this code and possibly achieve better
36398      throughput by exploiting instruction-level parallelism and
36399      therefore approximate more closely a non-profiled build. */
36400   JITTER_PROFILE_COUNT_UPDATE
36401      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36402       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36403 #endif
36404 
36405 /* User-specified code, instruction-beginning-c part: beginning. */
36406 
36407 /* User-specified code, instruction-beginning-c part: end */
36408 
36409 
36410     /* User code for pushr/%rR . */
36411 #line 2178 "../../libpoke/pvm.jitter"
36412 
36413     JITTER_PUSH_STACK (JITTER_ARG0);
36414 
36415     /* End of the user code for pushr/%rR . */
36416 
36417 /* User-specified code, instruction-end-c part: beginning. */
36418 
36419 /* User-specified code, instruction-end-c part: end */
36420 
36421     /* Undefine the pushr/%rR argument macros so they can't be used
36422        by mistake in the instruction body coming next. */
36423 #   undef JITTER_SLOW_REGISTER_OFFSET0
36424 #   undef JITTER_ARG0
36425 #   undef JITTER_ARGN0
36426 #   undef JITTER_ARGU0
36427 #   undef JITTER_ARGP0
36428 #   undef JITTER_ARGF0
36429 
36430 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36431 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36432 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36433 
36434   }
36435  JITTER_INSTRUCTION_EPILOG_(pushr/%rR, pushr___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36436 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36437 
36438   JITTER_INSTRUCTION_PROLOG_(pushtopvar/nR, pushtopvar__nR, cold)
36439   {
36440     /* This specialized instruction is not a replacement. */
36441 #   undef JITTER_BRANCH_FAST
36442 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36443 #   undef JITTER_BRANCH_FAST_IF_ZERO
36444 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36445 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36446 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36447 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36448 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36449 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36450 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36451 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36452 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36453 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36454 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36455 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36456 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36457 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36458 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36459 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36460 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36461 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36462 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36463 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36464 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36465 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36466 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36467 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36468 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36469 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36470 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36471 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36472 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36473 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36474 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36475 #   undef JITTER_BRANCH_FAST_IF_AND
36476 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36477 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36478 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36479 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36480 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36481 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36482 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36483 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36484 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36485 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36486 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36487 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36488 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36489 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36490 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36491 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36492 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36493 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36494 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36495 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36496 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36497 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36498 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36499 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36500 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36501 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36502 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36503 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36504 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36505 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       252
36506 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushtopvar/nR
36507 
36508 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushtopvar__nR
36509 
36510   /* The residual arity for this instruction does not depend on fast labels. */
36511   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
36512 
36513     /* The 0th argument is a residual literal. */
36514 #if defined(JITTER_DISPATCH_NO_THREADING)
36515 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
36516     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
36517 #elif defined (JITTER_REPLICATE)
36518 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
36519 #else
36520 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
36521 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
36522 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36523 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36524 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36525 #   define JITTER_ARGF0 JITTER_ARGP0
36526 
36527 
36528 #if defined (JITTER_PROFILE_SAMPLE)
36529   JITTER_PROFILE_SAMPLE_UPDATE
36530      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36531       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36532   /* Force the compiler not move sample-profiling instrumentation
36533      beyond this point; this way the actual user code is timed.
36534      This is still not perfect, as residuals are materialised before
36535      we arrive here, but should be adequate at least for slow VM
36536      instructions. */
36537   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36538 #endif
36539 #if defined (JITTER_PROFILE_COUNT)
36540   /* Notice that, differently from the code above, this
36541      instrumentation code *can* be reordered freely: as long as a
36542      VM instruction is counted, the count increment can be placed
36543      anyehere.  Let GCC move this code and possibly achieve better
36544      throughput by exploiting instruction-level parallelism and
36545      therefore approximate more closely a non-profiled build. */
36546   JITTER_PROFILE_COUNT_UPDATE
36547      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36548       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36549 #endif
36550 
36551 /* User-specified code, instruction-beginning-c part: beginning. */
36552 
36553 /* User-specified code, instruction-beginning-c part: end */
36554 
36555 
36556     /* User code for pushtopvar/nR . */
36557 #line 1664 "../../libpoke/pvm.jitter"
36558 
36559     pvm_env topenv = pvm_env_toplevel (jitter_state_runtime.env);
36560     pvm_val val = pvm_env_lookup (topenv, 0 /* back */,
36561                                   (int) JITTER_ARGN0 /* over */);
36562 
36563     if (val == PVM_NULL)
36564       PVM_RAISE (PVM_E_INVAL, "no top-level variable found",
36565                  PVM_E_INVAL_ESTATUS);
36566 
36567     JITTER_PUSH_STACK (val);
36568 
36569     /* End of the user code for pushtopvar/nR . */
36570 
36571 /* User-specified code, instruction-end-c part: beginning. */
36572 
36573 /* User-specified code, instruction-end-c part: end */
36574 
36575     /* Undefine the pushtopvar/nR argument macros so they can't be used
36576        by mistake in the instruction body coming next. */
36577 #   undef JITTER_SLOW_REGISTER_OFFSET0
36578 #   undef JITTER_ARG0
36579 #   undef JITTER_ARGN0
36580 #   undef JITTER_ARGU0
36581 #   undef JITTER_ARGP0
36582 #   undef JITTER_ARGF0
36583 
36584 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36585 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36586 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36587 
36588   }
36589  JITTER_INSTRUCTION_EPILOG_(pushtopvar/nR, pushtopvar__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36590 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36591 
36592   JITTER_INSTRUCTION_PROLOG_(pushvar/n0/n0, pushvar__n0__n0, hot)
36593   {
36594     /* This specialized instruction is not a replacement. */
36595 #   undef JITTER_BRANCH_FAST
36596 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36597 #   undef JITTER_BRANCH_FAST_IF_ZERO
36598 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36599 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36600 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36601 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36602 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36603 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36604 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36605 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36606 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36607 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36608 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36609 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36610 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36611 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36612 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36613 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36614 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36615 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36616 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36617 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36618 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36619 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36620 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36621 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36622 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36623 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36624 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36625 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36626 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36627 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36628 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36629 #   undef JITTER_BRANCH_FAST_IF_AND
36630 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36631 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36632 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36633 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36634 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36635 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36636 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36637 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36638 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36639 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36640 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36641 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36642 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36643 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36644 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36645 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36646 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36647 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36648 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36649 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36650 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36651 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36652 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36653 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36654 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36655 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36656 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36657 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36658 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36659 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       253
36660 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/n0/n0
36661 
36662 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__n0__n0
36663 
36664   /* The residual arity for this instruction does not depend on fast labels. */
36665   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36666 
36667     /* The 0th argument is a nonresidual literal. */
36668 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
36669 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36670 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36671 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36672 #   define JITTER_ARGF0 JITTER_ARGP0
36673 
36674     /* The 1th argument is a nonresidual literal. */
36675 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
36676 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
36677 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
36678 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
36679 #   define JITTER_ARGF1 JITTER_ARGP1
36680 
36681 
36682 #if defined (JITTER_PROFILE_SAMPLE)
36683   JITTER_PROFILE_SAMPLE_UPDATE
36684      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36685       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36686   /* Force the compiler not move sample-profiling instrumentation
36687      beyond this point; this way the actual user code is timed.
36688      This is still not perfect, as residuals are materialised before
36689      we arrive here, but should be adequate at least for slow VM
36690      instructions. */
36691   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36692 #endif
36693 #if defined (JITTER_PROFILE_COUNT)
36694   /* Notice that, differently from the code above, this
36695      instrumentation code *can* be reordered freely: as long as a
36696      VM instruction is counted, the count increment can be placed
36697      anyehere.  Let GCC move this code and possibly achieve better
36698      throughput by exploiting instruction-level parallelism and
36699      therefore approximate more closely a non-profiled build. */
36700   JITTER_PROFILE_COUNT_UPDATE
36701      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36702       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36703 #endif
36704 
36705 /* User-specified code, instruction-beginning-c part: beginning. */
36706 
36707 /* User-specified code, instruction-beginning-c part: end */
36708 
36709 
36710     /* User code for pushvar/n0/n0 . */
36711 #line 1645 "../../libpoke/pvm.jitter"
36712 
36713     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
36714                                        (int) JITTER_ARGN0,
36715                                        (int) JITTER_ARGN1));
36716 
36717     /* End of the user code for pushvar/n0/n0 . */
36718 
36719 /* User-specified code, instruction-end-c part: beginning. */
36720 
36721 /* User-specified code, instruction-end-c part: end */
36722 
36723     /* Undefine the pushvar/n0/n0 argument macros so they can't be used
36724        by mistake in the instruction body coming next. */
36725 #   undef JITTER_SLOW_REGISTER_OFFSET0
36726 #   undef JITTER_ARG0
36727 #   undef JITTER_ARGN0
36728 #   undef JITTER_ARGU0
36729 #   undef JITTER_ARGP0
36730 #   undef JITTER_ARGF0
36731 #   undef JITTER_SLOW_REGISTER_OFFSET1
36732 #   undef JITTER_ARG1
36733 #   undef JITTER_ARGN1
36734 #   undef JITTER_ARGU1
36735 #   undef JITTER_ARGP1
36736 #   undef JITTER_ARGF1
36737 
36738 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36739 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36740 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36741 
36742   }
36743  JITTER_INSTRUCTION_EPILOG_(pushvar/n0/n0, pushvar__n0__n0, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36744 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36745 
36746   JITTER_INSTRUCTION_PROLOG_(pushvar/n0/n1, pushvar__n0__n1, hot)
36747   {
36748     /* This specialized instruction is not a replacement. */
36749 #   undef JITTER_BRANCH_FAST
36750 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36751 #   undef JITTER_BRANCH_FAST_IF_ZERO
36752 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36753 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36754 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36755 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36756 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36757 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36758 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36759 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36760 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36761 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36762 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36763 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36764 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36765 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36766 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36767 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36768 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36769 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36770 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36771 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36772 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36773 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36774 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36775 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36776 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36777 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36778 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36779 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36780 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36781 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36782 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36783 #   undef JITTER_BRANCH_FAST_IF_AND
36784 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36785 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36786 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36787 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36788 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36789 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36790 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36791 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36792 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36793 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36794 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36795 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36796 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36797 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36798 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36799 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36800 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36801 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36802 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36803 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36804 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36805 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36806 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36807 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36808 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36809 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36810 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36811 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36812 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36813 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       254
36814 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/n0/n1
36815 
36816 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__n0__n1
36817 
36818   /* The residual arity for this instruction does not depend on fast labels. */
36819   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36820 
36821     /* The 0th argument is a nonresidual literal. */
36822 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
36823 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36824 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36825 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36826 #   define JITTER_ARGF0 JITTER_ARGP0
36827 
36828     /* The 1th argument is a nonresidual literal. */
36829 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
36830 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
36831 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
36832 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
36833 #   define JITTER_ARGF1 JITTER_ARGP1
36834 
36835 
36836 #if defined (JITTER_PROFILE_SAMPLE)
36837   JITTER_PROFILE_SAMPLE_UPDATE
36838      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36839       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36840   /* Force the compiler not move sample-profiling instrumentation
36841      beyond this point; this way the actual user code is timed.
36842      This is still not perfect, as residuals are materialised before
36843      we arrive here, but should be adequate at least for slow VM
36844      instructions. */
36845   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36846 #endif
36847 #if defined (JITTER_PROFILE_COUNT)
36848   /* Notice that, differently from the code above, this
36849      instrumentation code *can* be reordered freely: as long as a
36850      VM instruction is counted, the count increment can be placed
36851      anyehere.  Let GCC move this code and possibly achieve better
36852      throughput by exploiting instruction-level parallelism and
36853      therefore approximate more closely a non-profiled build. */
36854   JITTER_PROFILE_COUNT_UPDATE
36855      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36856       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36857 #endif
36858 
36859 /* User-specified code, instruction-beginning-c part: beginning. */
36860 
36861 /* User-specified code, instruction-beginning-c part: end */
36862 
36863 
36864     /* User code for pushvar/n0/n1 . */
36865 #line 1645 "../../libpoke/pvm.jitter"
36866 
36867     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
36868                                        (int) JITTER_ARGN0,
36869                                        (int) JITTER_ARGN1));
36870 
36871     /* End of the user code for pushvar/n0/n1 . */
36872 
36873 /* User-specified code, instruction-end-c part: beginning. */
36874 
36875 /* User-specified code, instruction-end-c part: end */
36876 
36877     /* Undefine the pushvar/n0/n1 argument macros so they can't be used
36878        by mistake in the instruction body coming next. */
36879 #   undef JITTER_SLOW_REGISTER_OFFSET0
36880 #   undef JITTER_ARG0
36881 #   undef JITTER_ARGN0
36882 #   undef JITTER_ARGU0
36883 #   undef JITTER_ARGP0
36884 #   undef JITTER_ARGF0
36885 #   undef JITTER_SLOW_REGISTER_OFFSET1
36886 #   undef JITTER_ARG1
36887 #   undef JITTER_ARGN1
36888 #   undef JITTER_ARGU1
36889 #   undef JITTER_ARGP1
36890 #   undef JITTER_ARGF1
36891 
36892 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36893 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36894 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36895 
36896   }
36897  JITTER_INSTRUCTION_EPILOG_(pushvar/n0/n1, pushvar__n0__n1, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36898 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36899 
36900   JITTER_INSTRUCTION_PROLOG_(pushvar/n0/n2, pushvar__n0__n2, hot)
36901   {
36902     /* This specialized instruction is not a replacement. */
36903 #   undef JITTER_BRANCH_FAST
36904 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36905 #   undef JITTER_BRANCH_FAST_IF_ZERO
36906 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36907 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36908 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36909 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36910 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36911 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36912 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36913 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36914 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36915 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36916 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36917 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36918 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36919 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36920 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36921 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36922 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36923 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36924 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36925 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36926 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36927 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36928 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36929 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36930 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36931 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36932 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36933 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36934 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36935 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36936 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36937 #   undef JITTER_BRANCH_FAST_IF_AND
36938 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36939 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36940 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36941 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36942 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36943 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36944 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36945 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36946 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36947 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36948 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36949 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36950 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36951 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36952 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36953 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36954 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36955 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36956 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36957 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36958 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36959 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36960 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36961 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36962 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36963 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36964 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36965 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36966 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36967 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       255
36968 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/n0/n2
36969 
36970 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__n0__n2
36971 
36972   /* The residual arity for this instruction does not depend on fast labels. */
36973   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36974 
36975     /* The 0th argument is a nonresidual literal. */
36976 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
36977 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36978 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36979 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36980 #   define JITTER_ARGF0 JITTER_ARGP0
36981 
36982     /* The 1th argument is a nonresidual literal. */
36983 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
36984 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
36985 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
36986 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
36987 #   define JITTER_ARGF1 JITTER_ARGP1
36988 
36989 
36990 #if defined (JITTER_PROFILE_SAMPLE)
36991   JITTER_PROFILE_SAMPLE_UPDATE
36992      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36993       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36994   /* Force the compiler not move sample-profiling instrumentation
36995      beyond this point; this way the actual user code is timed.
36996      This is still not perfect, as residuals are materialised before
36997      we arrive here, but should be adequate at least for slow VM
36998      instructions. */
36999   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37000 #endif
37001 #if defined (JITTER_PROFILE_COUNT)
37002   /* Notice that, differently from the code above, this
37003      instrumentation code *can* be reordered freely: as long as a
37004      VM instruction is counted, the count increment can be placed
37005      anyehere.  Let GCC move this code and possibly achieve better
37006      throughput by exploiting instruction-level parallelism and
37007      therefore approximate more closely a non-profiled build. */
37008   JITTER_PROFILE_COUNT_UPDATE
37009      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37010       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37011 #endif
37012 
37013 /* User-specified code, instruction-beginning-c part: beginning. */
37014 
37015 /* User-specified code, instruction-beginning-c part: end */
37016 
37017 
37018     /* User code for pushvar/n0/n2 . */
37019 #line 1645 "../../libpoke/pvm.jitter"
37020 
37021     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
37022                                        (int) JITTER_ARGN0,
37023                                        (int) JITTER_ARGN1));
37024 
37025     /* End of the user code for pushvar/n0/n2 . */
37026 
37027 /* User-specified code, instruction-end-c part: beginning. */
37028 
37029 /* User-specified code, instruction-end-c part: end */
37030 
37031     /* Undefine the pushvar/n0/n2 argument macros so they can't be used
37032        by mistake in the instruction body coming next. */
37033 #   undef JITTER_SLOW_REGISTER_OFFSET0
37034 #   undef JITTER_ARG0
37035 #   undef JITTER_ARGN0
37036 #   undef JITTER_ARGU0
37037 #   undef JITTER_ARGP0
37038 #   undef JITTER_ARGF0
37039 #   undef JITTER_SLOW_REGISTER_OFFSET1
37040 #   undef JITTER_ARG1
37041 #   undef JITTER_ARGN1
37042 #   undef JITTER_ARGU1
37043 #   undef JITTER_ARGP1
37044 #   undef JITTER_ARGF1
37045 
37046 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37047 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37048 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37049 
37050   }
37051  JITTER_INSTRUCTION_EPILOG_(pushvar/n0/n2, pushvar__n0__n2, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37052 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37053 
37054   JITTER_INSTRUCTION_PROLOG_(pushvar/n0/n3, pushvar__n0__n3, hot)
37055   {
37056     /* This specialized instruction is not a replacement. */
37057 #   undef JITTER_BRANCH_FAST
37058 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37059 #   undef JITTER_BRANCH_FAST_IF_ZERO
37060 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37061 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37062 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37063 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37064 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37065 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37066 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37067 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37068 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37069 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37070 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37071 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37072 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37073 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37074 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37075 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37076 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37077 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37078 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37079 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37080 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37081 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37082 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37083 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37084 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37085 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37086 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37087 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37088 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37089 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37090 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37091 #   undef JITTER_BRANCH_FAST_IF_AND
37092 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37093 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37094 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37095 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37096 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37097 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37098 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37099 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37100 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37101 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37102 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37103 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37104 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37105 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37106 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37107 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37108 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37109 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37110 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37111 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37112 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37113 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37114 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37115 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37116 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37117 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37118 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37119 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37120 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37121 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       256
37122 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/n0/n3
37123 
37124 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__n0__n3
37125 
37126   /* The residual arity for this instruction does not depend on fast labels. */
37127   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37128 
37129     /* The 0th argument is a nonresidual literal. */
37130 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
37131 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37132 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37133 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37134 #   define JITTER_ARGF0 JITTER_ARGP0
37135 
37136     /* The 1th argument is a nonresidual literal. */
37137 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
37138 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
37139 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
37140 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
37141 #   define JITTER_ARGF1 JITTER_ARGP1
37142 
37143 
37144 #if defined (JITTER_PROFILE_SAMPLE)
37145   JITTER_PROFILE_SAMPLE_UPDATE
37146      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37147       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37148   /* Force the compiler not move sample-profiling instrumentation
37149      beyond this point; this way the actual user code is timed.
37150      This is still not perfect, as residuals are materialised before
37151      we arrive here, but should be adequate at least for slow VM
37152      instructions. */
37153   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37154 #endif
37155 #if defined (JITTER_PROFILE_COUNT)
37156   /* Notice that, differently from the code above, this
37157      instrumentation code *can* be reordered freely: as long as a
37158      VM instruction is counted, the count increment can be placed
37159      anyehere.  Let GCC move this code and possibly achieve better
37160      throughput by exploiting instruction-level parallelism and
37161      therefore approximate more closely a non-profiled build. */
37162   JITTER_PROFILE_COUNT_UPDATE
37163      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37164       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37165 #endif
37166 
37167 /* User-specified code, instruction-beginning-c part: beginning. */
37168 
37169 /* User-specified code, instruction-beginning-c part: end */
37170 
37171 
37172     /* User code for pushvar/n0/n3 . */
37173 #line 1645 "../../libpoke/pvm.jitter"
37174 
37175     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
37176                                        (int) JITTER_ARGN0,
37177                                        (int) JITTER_ARGN1));
37178 
37179     /* End of the user code for pushvar/n0/n3 . */
37180 
37181 /* User-specified code, instruction-end-c part: beginning. */
37182 
37183 /* User-specified code, instruction-end-c part: end */
37184 
37185     /* Undefine the pushvar/n0/n3 argument macros so they can't be used
37186        by mistake in the instruction body coming next. */
37187 #   undef JITTER_SLOW_REGISTER_OFFSET0
37188 #   undef JITTER_ARG0
37189 #   undef JITTER_ARGN0
37190 #   undef JITTER_ARGU0
37191 #   undef JITTER_ARGP0
37192 #   undef JITTER_ARGF0
37193 #   undef JITTER_SLOW_REGISTER_OFFSET1
37194 #   undef JITTER_ARG1
37195 #   undef JITTER_ARGN1
37196 #   undef JITTER_ARGU1
37197 #   undef JITTER_ARGP1
37198 #   undef JITTER_ARGF1
37199 
37200 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37201 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37202 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37203 
37204   }
37205  JITTER_INSTRUCTION_EPILOG_(pushvar/n0/n3, pushvar__n0__n3, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37206 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37207 
37208   JITTER_INSTRUCTION_PROLOG_(pushvar/n0/n4, pushvar__n0__n4, hot)
37209   {
37210     /* This specialized instruction is not a replacement. */
37211 #   undef JITTER_BRANCH_FAST
37212 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37213 #   undef JITTER_BRANCH_FAST_IF_ZERO
37214 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37215 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37216 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37217 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37218 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37219 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37220 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37221 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37222 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37223 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37224 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37225 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37226 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37227 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37228 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37229 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37230 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37231 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37232 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37233 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37234 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37235 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37236 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37237 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37238 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37239 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37240 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37241 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37242 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37243 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37244 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37245 #   undef JITTER_BRANCH_FAST_IF_AND
37246 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37247 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37248 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37249 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37250 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37251 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37252 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37253 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37254 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37255 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37256 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37257 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37258 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37259 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37260 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37261 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37262 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37263 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37264 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37265 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37266 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37267 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37268 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37269 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37270 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37271 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37272 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37273 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37274 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37275 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       257
37276 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/n0/n4
37277 
37278 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__n0__n4
37279 
37280   /* The residual arity for this instruction does not depend on fast labels. */
37281   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37282 
37283     /* The 0th argument is a nonresidual literal. */
37284 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
37285 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37286 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37287 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37288 #   define JITTER_ARGF0 JITTER_ARGP0
37289 
37290     /* The 1th argument is a nonresidual literal. */
37291 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
37292 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
37293 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
37294 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
37295 #   define JITTER_ARGF1 JITTER_ARGP1
37296 
37297 
37298 #if defined (JITTER_PROFILE_SAMPLE)
37299   JITTER_PROFILE_SAMPLE_UPDATE
37300      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37301       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37302   /* Force the compiler not move sample-profiling instrumentation
37303      beyond this point; this way the actual user code is timed.
37304      This is still not perfect, as residuals are materialised before
37305      we arrive here, but should be adequate at least for slow VM
37306      instructions. */
37307   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37308 #endif
37309 #if defined (JITTER_PROFILE_COUNT)
37310   /* Notice that, differently from the code above, this
37311      instrumentation code *can* be reordered freely: as long as a
37312      VM instruction is counted, the count increment can be placed
37313      anyehere.  Let GCC move this code and possibly achieve better
37314      throughput by exploiting instruction-level parallelism and
37315      therefore approximate more closely a non-profiled build. */
37316   JITTER_PROFILE_COUNT_UPDATE
37317      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37318       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37319 #endif
37320 
37321 /* User-specified code, instruction-beginning-c part: beginning. */
37322 
37323 /* User-specified code, instruction-beginning-c part: end */
37324 
37325 
37326     /* User code for pushvar/n0/n4 . */
37327 #line 1645 "../../libpoke/pvm.jitter"
37328 
37329     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
37330                                        (int) JITTER_ARGN0,
37331                                        (int) JITTER_ARGN1));
37332 
37333     /* End of the user code for pushvar/n0/n4 . */
37334 
37335 /* User-specified code, instruction-end-c part: beginning. */
37336 
37337 /* User-specified code, instruction-end-c part: end */
37338 
37339     /* Undefine the pushvar/n0/n4 argument macros so they can't be used
37340        by mistake in the instruction body coming next. */
37341 #   undef JITTER_SLOW_REGISTER_OFFSET0
37342 #   undef JITTER_ARG0
37343 #   undef JITTER_ARGN0
37344 #   undef JITTER_ARGU0
37345 #   undef JITTER_ARGP0
37346 #   undef JITTER_ARGF0
37347 #   undef JITTER_SLOW_REGISTER_OFFSET1
37348 #   undef JITTER_ARG1
37349 #   undef JITTER_ARGN1
37350 #   undef JITTER_ARGU1
37351 #   undef JITTER_ARGP1
37352 #   undef JITTER_ARGF1
37353 
37354 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37355 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37356 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37357 
37358   }
37359  JITTER_INSTRUCTION_EPILOG_(pushvar/n0/n4, pushvar__n0__n4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37360 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37361 
37362   JITTER_INSTRUCTION_PROLOG_(pushvar/n0/n5, pushvar__n0__n5, hot)
37363   {
37364     /* This specialized instruction is not a replacement. */
37365 #   undef JITTER_BRANCH_FAST
37366 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37367 #   undef JITTER_BRANCH_FAST_IF_ZERO
37368 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37369 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37370 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37371 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37372 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37373 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37374 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37375 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37376 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37377 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37378 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37379 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37380 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37381 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37382 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37383 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37384 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37385 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37386 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37387 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37388 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37389 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37390 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37391 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37392 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37393 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37394 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37395 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37396 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37397 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37398 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37399 #   undef JITTER_BRANCH_FAST_IF_AND
37400 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37401 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37402 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37403 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37404 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37405 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37406 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37407 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37408 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37409 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37410 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37411 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37412 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37413 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37414 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37415 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37416 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37417 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37418 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37419 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37420 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37421 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37422 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37423 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37424 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37425 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37426 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37427 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37428 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37429 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       258
37430 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/n0/n5
37431 
37432 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__n0__n5
37433 
37434   /* The residual arity for this instruction does not depend on fast labels. */
37435   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37436 
37437     /* The 0th argument is a nonresidual literal. */
37438 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
37439 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37440 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37441 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37442 #   define JITTER_ARGF0 JITTER_ARGP0
37443 
37444     /* The 1th argument is a nonresidual literal. */
37445 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 5L})
37446 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
37447 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
37448 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
37449 #   define JITTER_ARGF1 JITTER_ARGP1
37450 
37451 
37452 #if defined (JITTER_PROFILE_SAMPLE)
37453   JITTER_PROFILE_SAMPLE_UPDATE
37454      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37455       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37456   /* Force the compiler not move sample-profiling instrumentation
37457      beyond this point; this way the actual user code is timed.
37458      This is still not perfect, as residuals are materialised before
37459      we arrive here, but should be adequate at least for slow VM
37460      instructions. */
37461   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37462 #endif
37463 #if defined (JITTER_PROFILE_COUNT)
37464   /* Notice that, differently from the code above, this
37465      instrumentation code *can* be reordered freely: as long as a
37466      VM instruction is counted, the count increment can be placed
37467      anyehere.  Let GCC move this code and possibly achieve better
37468      throughput by exploiting instruction-level parallelism and
37469      therefore approximate more closely a non-profiled build. */
37470   JITTER_PROFILE_COUNT_UPDATE
37471      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37472       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37473 #endif
37474 
37475 /* User-specified code, instruction-beginning-c part: beginning. */
37476 
37477 /* User-specified code, instruction-beginning-c part: end */
37478 
37479 
37480     /* User code for pushvar/n0/n5 . */
37481 #line 1645 "../../libpoke/pvm.jitter"
37482 
37483     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
37484                                        (int) JITTER_ARGN0,
37485                                        (int) JITTER_ARGN1));
37486 
37487     /* End of the user code for pushvar/n0/n5 . */
37488 
37489 /* User-specified code, instruction-end-c part: beginning. */
37490 
37491 /* User-specified code, instruction-end-c part: end */
37492 
37493     /* Undefine the pushvar/n0/n5 argument macros so they can't be used
37494        by mistake in the instruction body coming next. */
37495 #   undef JITTER_SLOW_REGISTER_OFFSET0
37496 #   undef JITTER_ARG0
37497 #   undef JITTER_ARGN0
37498 #   undef JITTER_ARGU0
37499 #   undef JITTER_ARGP0
37500 #   undef JITTER_ARGF0
37501 #   undef JITTER_SLOW_REGISTER_OFFSET1
37502 #   undef JITTER_ARG1
37503 #   undef JITTER_ARGN1
37504 #   undef JITTER_ARGU1
37505 #   undef JITTER_ARGP1
37506 #   undef JITTER_ARGF1
37507 
37508 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37509 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37510 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37511 
37512   }
37513  JITTER_INSTRUCTION_EPILOG_(pushvar/n0/n5, pushvar__n0__n5, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37514 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37515 
37516   JITTER_INSTRUCTION_PROLOG_(pushvar/n0/nR, pushvar__n0__nR, cold)
37517   {
37518     /* This specialized instruction is not a replacement. */
37519 #   undef JITTER_BRANCH_FAST
37520 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37521 #   undef JITTER_BRANCH_FAST_IF_ZERO
37522 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37523 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37524 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37525 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37526 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37527 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37528 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37529 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37530 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37531 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37532 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37533 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37534 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37535 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37536 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37537 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37538 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37539 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37540 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37541 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37542 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37543 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37544 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37545 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37546 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37547 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37548 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37549 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37550 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37551 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37552 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37553 #   undef JITTER_BRANCH_FAST_IF_AND
37554 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37555 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37556 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37557 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37558 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37559 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37560 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37561 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37562 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37563 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37564 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37565 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37566 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37567 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37568 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37569 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37570 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37571 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37572 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37573 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37574 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37575 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37576 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37577 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37578 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37579 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37580 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37581 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37582 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37583 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       259
37584 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/n0/nR
37585 
37586 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__n0__nR
37587 
37588   /* The residual arity for this instruction does not depend on fast labels. */
37589   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
37590 
37591     /* The 0th argument is a nonresidual literal. */
37592 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
37593 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37594 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37595 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37596 #   define JITTER_ARGF0 JITTER_ARGP0
37597 
37598     /* The 1th argument is a residual literal. */
37599 #if defined(JITTER_DISPATCH_NO_THREADING)
37600 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
37601     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
37602 #elif defined (JITTER_REPLICATE)
37603 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
37604 #else
37605 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
37606 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
37607 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
37608 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
37609 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
37610 #   define JITTER_ARGF1 JITTER_ARGP1
37611 
37612 
37613 #if defined (JITTER_PROFILE_SAMPLE)
37614   JITTER_PROFILE_SAMPLE_UPDATE
37615      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37616       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37617   /* Force the compiler not move sample-profiling instrumentation
37618      beyond this point; this way the actual user code is timed.
37619      This is still not perfect, as residuals are materialised before
37620      we arrive here, but should be adequate at least for slow VM
37621      instructions. */
37622   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37623 #endif
37624 #if defined (JITTER_PROFILE_COUNT)
37625   /* Notice that, differently from the code above, this
37626      instrumentation code *can* be reordered freely: as long as a
37627      VM instruction is counted, the count increment can be placed
37628      anyehere.  Let GCC move this code and possibly achieve better
37629      throughput by exploiting instruction-level parallelism and
37630      therefore approximate more closely a non-profiled build. */
37631   JITTER_PROFILE_COUNT_UPDATE
37632      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37633       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37634 #endif
37635 
37636 /* User-specified code, instruction-beginning-c part: beginning. */
37637 
37638 /* User-specified code, instruction-beginning-c part: end */
37639 
37640 
37641     /* User code for pushvar/n0/nR . */
37642 #line 1645 "../../libpoke/pvm.jitter"
37643 
37644     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
37645                                        (int) JITTER_ARGN0,
37646                                        (int) JITTER_ARGN1));
37647 
37648     /* End of the user code for pushvar/n0/nR . */
37649 
37650 /* User-specified code, instruction-end-c part: beginning. */
37651 
37652 /* User-specified code, instruction-end-c part: end */
37653 
37654     /* Undefine the pushvar/n0/nR argument macros so they can't be used
37655        by mistake in the instruction body coming next. */
37656 #   undef JITTER_SLOW_REGISTER_OFFSET0
37657 #   undef JITTER_ARG0
37658 #   undef JITTER_ARGN0
37659 #   undef JITTER_ARGU0
37660 #   undef JITTER_ARGP0
37661 #   undef JITTER_ARGF0
37662 #   undef JITTER_SLOW_REGISTER_OFFSET1
37663 #   undef JITTER_ARG1
37664 #   undef JITTER_ARGN1
37665 #   undef JITTER_ARGU1
37666 #   undef JITTER_ARGP1
37667 #   undef JITTER_ARGF1
37668 
37669 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37670 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37671 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37672 
37673   }
37674  JITTER_INSTRUCTION_EPILOG_(pushvar/n0/nR, pushvar__n0__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37675 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37676 
37677   JITTER_INSTRUCTION_PROLOG_(pushvar/nR/n0, pushvar__nR__n0, cold)
37678   {
37679     /* This specialized instruction is not a replacement. */
37680 #   undef JITTER_BRANCH_FAST
37681 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37682 #   undef JITTER_BRANCH_FAST_IF_ZERO
37683 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37684 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37685 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37686 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37687 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37688 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37689 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37690 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37691 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37692 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37693 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37694 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37695 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37696 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37697 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37698 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37699 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37700 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37701 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37702 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37703 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37704 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37705 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37706 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37707 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37708 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37709 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37710 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37711 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37712 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37713 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37714 #   undef JITTER_BRANCH_FAST_IF_AND
37715 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37716 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37717 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37718 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37719 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37720 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37721 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37722 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37723 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37724 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37725 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37726 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37727 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37728 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37729 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37730 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37731 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37732 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37733 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37734 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37735 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37736 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37737 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37738 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37739 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37740 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37741 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37742 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37743 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37744 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       260
37745 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/nR/n0
37746 
37747 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__nR__n0
37748 
37749   /* The residual arity for this instruction does not depend on fast labels. */
37750   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
37751 
37752     /* The 0th argument is a residual literal. */
37753 #if defined(JITTER_DISPATCH_NO_THREADING)
37754 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
37755     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
37756 #elif defined (JITTER_REPLICATE)
37757 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
37758 #else
37759 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
37760 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
37761 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37762 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37763 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37764 #   define JITTER_ARGF0 JITTER_ARGP0
37765 
37766     /* The 1th argument is a nonresidual literal. */
37767 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
37768 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
37769 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
37770 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
37771 #   define JITTER_ARGF1 JITTER_ARGP1
37772 
37773 
37774 #if defined (JITTER_PROFILE_SAMPLE)
37775   JITTER_PROFILE_SAMPLE_UPDATE
37776      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37777       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37778   /* Force the compiler not move sample-profiling instrumentation
37779      beyond this point; this way the actual user code is timed.
37780      This is still not perfect, as residuals are materialised before
37781      we arrive here, but should be adequate at least for slow VM
37782      instructions. */
37783   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37784 #endif
37785 #if defined (JITTER_PROFILE_COUNT)
37786   /* Notice that, differently from the code above, this
37787      instrumentation code *can* be reordered freely: as long as a
37788      VM instruction is counted, the count increment can be placed
37789      anyehere.  Let GCC move this code and possibly achieve better
37790      throughput by exploiting instruction-level parallelism and
37791      therefore approximate more closely a non-profiled build. */
37792   JITTER_PROFILE_COUNT_UPDATE
37793      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37794       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37795 #endif
37796 
37797 /* User-specified code, instruction-beginning-c part: beginning. */
37798 
37799 /* User-specified code, instruction-beginning-c part: end */
37800 
37801 
37802     /* User code for pushvar/nR/n0 . */
37803 #line 1645 "../../libpoke/pvm.jitter"
37804 
37805     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
37806                                        (int) JITTER_ARGN0,
37807                                        (int) JITTER_ARGN1));
37808 
37809     /* End of the user code for pushvar/nR/n0 . */
37810 
37811 /* User-specified code, instruction-end-c part: beginning. */
37812 
37813 /* User-specified code, instruction-end-c part: end */
37814 
37815     /* Undefine the pushvar/nR/n0 argument macros so they can't be used
37816        by mistake in the instruction body coming next. */
37817 #   undef JITTER_SLOW_REGISTER_OFFSET0
37818 #   undef JITTER_ARG0
37819 #   undef JITTER_ARGN0
37820 #   undef JITTER_ARGU0
37821 #   undef JITTER_ARGP0
37822 #   undef JITTER_ARGF0
37823 #   undef JITTER_SLOW_REGISTER_OFFSET1
37824 #   undef JITTER_ARG1
37825 #   undef JITTER_ARGN1
37826 #   undef JITTER_ARGU1
37827 #   undef JITTER_ARGP1
37828 #   undef JITTER_ARGF1
37829 
37830 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37831 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37832 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37833 
37834   }
37835  JITTER_INSTRUCTION_EPILOG_(pushvar/nR/n0, pushvar__nR__n0, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37836 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37837 
37838   JITTER_INSTRUCTION_PROLOG_(pushvar/nR/n1, pushvar__nR__n1, cold)
37839   {
37840     /* This specialized instruction is not a replacement. */
37841 #   undef JITTER_BRANCH_FAST
37842 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37843 #   undef JITTER_BRANCH_FAST_IF_ZERO
37844 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37845 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37846 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37847 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37848 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37849 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37850 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37851 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37852 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37853 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37854 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37855 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37856 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37857 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37858 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37859 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37860 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37861 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37862 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37863 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37864 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37865 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37866 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37867 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37868 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37869 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37870 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37871 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37872 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37873 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37874 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37875 #   undef JITTER_BRANCH_FAST_IF_AND
37876 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37877 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37878 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37879 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37880 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37881 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37882 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37883 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37884 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37885 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37886 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37887 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37888 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37889 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37890 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37891 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37892 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37893 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37894 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37895 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37896 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37897 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37898 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37899 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37900 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37901 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37902 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37903 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37904 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37905 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       261
37906 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/nR/n1
37907 
37908 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__nR__n1
37909 
37910   /* The residual arity for this instruction does not depend on fast labels. */
37911   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
37912 
37913     /* The 0th argument is a residual literal. */
37914 #if defined(JITTER_DISPATCH_NO_THREADING)
37915 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
37916     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
37917 #elif defined (JITTER_REPLICATE)
37918 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
37919 #else
37920 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
37921 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
37922 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37923 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37924 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37925 #   define JITTER_ARGF0 JITTER_ARGP0
37926 
37927     /* The 1th argument is a nonresidual literal. */
37928 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
37929 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
37930 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
37931 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
37932 #   define JITTER_ARGF1 JITTER_ARGP1
37933 
37934 
37935 #if defined (JITTER_PROFILE_SAMPLE)
37936   JITTER_PROFILE_SAMPLE_UPDATE
37937      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37938       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37939   /* Force the compiler not move sample-profiling instrumentation
37940      beyond this point; this way the actual user code is timed.
37941      This is still not perfect, as residuals are materialised before
37942      we arrive here, but should be adequate at least for slow VM
37943      instructions. */
37944   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37945 #endif
37946 #if defined (JITTER_PROFILE_COUNT)
37947   /* Notice that, differently from the code above, this
37948      instrumentation code *can* be reordered freely: as long as a
37949      VM instruction is counted, the count increment can be placed
37950      anyehere.  Let GCC move this code and possibly achieve better
37951      throughput by exploiting instruction-level parallelism and
37952      therefore approximate more closely a non-profiled build. */
37953   JITTER_PROFILE_COUNT_UPDATE
37954      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37955       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37956 #endif
37957 
37958 /* User-specified code, instruction-beginning-c part: beginning. */
37959 
37960 /* User-specified code, instruction-beginning-c part: end */
37961 
37962 
37963     /* User code for pushvar/nR/n1 . */
37964 #line 1645 "../../libpoke/pvm.jitter"
37965 
37966     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
37967                                        (int) JITTER_ARGN0,
37968                                        (int) JITTER_ARGN1));
37969 
37970     /* End of the user code for pushvar/nR/n1 . */
37971 
37972 /* User-specified code, instruction-end-c part: beginning. */
37973 
37974 /* User-specified code, instruction-end-c part: end */
37975 
37976     /* Undefine the pushvar/nR/n1 argument macros so they can't be used
37977        by mistake in the instruction body coming next. */
37978 #   undef JITTER_SLOW_REGISTER_OFFSET0
37979 #   undef JITTER_ARG0
37980 #   undef JITTER_ARGN0
37981 #   undef JITTER_ARGU0
37982 #   undef JITTER_ARGP0
37983 #   undef JITTER_ARGF0
37984 #   undef JITTER_SLOW_REGISTER_OFFSET1
37985 #   undef JITTER_ARG1
37986 #   undef JITTER_ARGN1
37987 #   undef JITTER_ARGU1
37988 #   undef JITTER_ARGP1
37989 #   undef JITTER_ARGF1
37990 
37991 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37992 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37993 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37994 
37995   }
37996  JITTER_INSTRUCTION_EPILOG_(pushvar/nR/n1, pushvar__nR__n1, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37997 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37998 
37999   JITTER_INSTRUCTION_PROLOG_(pushvar/nR/n2, pushvar__nR__n2, cold)
38000   {
38001     /* This specialized instruction is not a replacement. */
38002 #   undef JITTER_BRANCH_FAST
38003 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38004 #   undef JITTER_BRANCH_FAST_IF_ZERO
38005 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38006 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38007 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38008 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38009 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38010 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38011 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38012 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38013 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38014 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38015 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38016 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38017 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38018 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38019 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38020 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38021 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38022 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38023 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38024 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38025 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38026 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38027 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38028 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38029 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38030 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38031 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38032 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38033 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38034 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38035 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38036 #   undef JITTER_BRANCH_FAST_IF_AND
38037 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38038 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38039 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38040 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38041 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38042 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38043 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38044 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38045 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38046 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38047 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38048 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38049 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38050 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38051 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38052 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38053 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38054 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38055 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38056 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38057 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38058 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38059 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38060 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38061 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38062 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38063 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38064 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38065 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38066 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       262
38067 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/nR/n2
38068 
38069 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__nR__n2
38070 
38071   /* The residual arity for this instruction does not depend on fast labels. */
38072   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
38073 
38074     /* The 0th argument is a residual literal. */
38075 #if defined(JITTER_DISPATCH_NO_THREADING)
38076 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38077     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38078 #elif defined (JITTER_REPLICATE)
38079 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38080 #else
38081 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38082 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38083 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38084 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38085 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38086 #   define JITTER_ARGF0 JITTER_ARGP0
38087 
38088     /* The 1th argument is a nonresidual literal. */
38089 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
38090 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
38091 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
38092 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
38093 #   define JITTER_ARGF1 JITTER_ARGP1
38094 
38095 
38096 #if defined (JITTER_PROFILE_SAMPLE)
38097   JITTER_PROFILE_SAMPLE_UPDATE
38098      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38099       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38100   /* Force the compiler not move sample-profiling instrumentation
38101      beyond this point; this way the actual user code is timed.
38102      This is still not perfect, as residuals are materialised before
38103      we arrive here, but should be adequate at least for slow VM
38104      instructions. */
38105   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38106 #endif
38107 #if defined (JITTER_PROFILE_COUNT)
38108   /* Notice that, differently from the code above, this
38109      instrumentation code *can* be reordered freely: as long as a
38110      VM instruction is counted, the count increment can be placed
38111      anyehere.  Let GCC move this code and possibly achieve better
38112      throughput by exploiting instruction-level parallelism and
38113      therefore approximate more closely a non-profiled build. */
38114   JITTER_PROFILE_COUNT_UPDATE
38115      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38116       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38117 #endif
38118 
38119 /* User-specified code, instruction-beginning-c part: beginning. */
38120 
38121 /* User-specified code, instruction-beginning-c part: end */
38122 
38123 
38124     /* User code for pushvar/nR/n2 . */
38125 #line 1645 "../../libpoke/pvm.jitter"
38126 
38127     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
38128                                        (int) JITTER_ARGN0,
38129                                        (int) JITTER_ARGN1));
38130 
38131     /* End of the user code for pushvar/nR/n2 . */
38132 
38133 /* User-specified code, instruction-end-c part: beginning. */
38134 
38135 /* User-specified code, instruction-end-c part: end */
38136 
38137     /* Undefine the pushvar/nR/n2 argument macros so they can't be used
38138        by mistake in the instruction body coming next. */
38139 #   undef JITTER_SLOW_REGISTER_OFFSET0
38140 #   undef JITTER_ARG0
38141 #   undef JITTER_ARGN0
38142 #   undef JITTER_ARGU0
38143 #   undef JITTER_ARGP0
38144 #   undef JITTER_ARGF0
38145 #   undef JITTER_SLOW_REGISTER_OFFSET1
38146 #   undef JITTER_ARG1
38147 #   undef JITTER_ARGN1
38148 #   undef JITTER_ARGU1
38149 #   undef JITTER_ARGP1
38150 #   undef JITTER_ARGF1
38151 
38152 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38153 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38154 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38155 
38156   }
38157  JITTER_INSTRUCTION_EPILOG_(pushvar/nR/n2, pushvar__nR__n2, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38158 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38159 
38160   JITTER_INSTRUCTION_PROLOG_(pushvar/nR/n3, pushvar__nR__n3, cold)
38161   {
38162     /* This specialized instruction is not a replacement. */
38163 #   undef JITTER_BRANCH_FAST
38164 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38165 #   undef JITTER_BRANCH_FAST_IF_ZERO
38166 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38167 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38168 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38169 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38170 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38171 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38172 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38173 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38174 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38175 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38176 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38177 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38178 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38179 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38180 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38181 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38182 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38183 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38184 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38185 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38186 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38187 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38188 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38189 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38190 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38191 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38192 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38193 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38194 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38195 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38196 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38197 #   undef JITTER_BRANCH_FAST_IF_AND
38198 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38199 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38200 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38201 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38202 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38203 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38204 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38205 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38206 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38207 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38208 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38209 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38210 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38211 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38212 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38213 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38214 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38215 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38216 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38217 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38218 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38219 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38220 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38221 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38222 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38223 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38224 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38225 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38226 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38227 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       263
38228 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/nR/n3
38229 
38230 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__nR__n3
38231 
38232   /* The residual arity for this instruction does not depend on fast labels. */
38233   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
38234 
38235     /* The 0th argument is a residual literal. */
38236 #if defined(JITTER_DISPATCH_NO_THREADING)
38237 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38238     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38239 #elif defined (JITTER_REPLICATE)
38240 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38241 #else
38242 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38243 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38244 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38245 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38246 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38247 #   define JITTER_ARGF0 JITTER_ARGP0
38248 
38249     /* The 1th argument is a nonresidual literal. */
38250 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
38251 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
38252 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
38253 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
38254 #   define JITTER_ARGF1 JITTER_ARGP1
38255 
38256 
38257 #if defined (JITTER_PROFILE_SAMPLE)
38258   JITTER_PROFILE_SAMPLE_UPDATE
38259      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38260       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38261   /* Force the compiler not move sample-profiling instrumentation
38262      beyond this point; this way the actual user code is timed.
38263      This is still not perfect, as residuals are materialised before
38264      we arrive here, but should be adequate at least for slow VM
38265      instructions. */
38266   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38267 #endif
38268 #if defined (JITTER_PROFILE_COUNT)
38269   /* Notice that, differently from the code above, this
38270      instrumentation code *can* be reordered freely: as long as a
38271      VM instruction is counted, the count increment can be placed
38272      anyehere.  Let GCC move this code and possibly achieve better
38273      throughput by exploiting instruction-level parallelism and
38274      therefore approximate more closely a non-profiled build. */
38275   JITTER_PROFILE_COUNT_UPDATE
38276      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38277       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38278 #endif
38279 
38280 /* User-specified code, instruction-beginning-c part: beginning. */
38281 
38282 /* User-specified code, instruction-beginning-c part: end */
38283 
38284 
38285     /* User code for pushvar/nR/n3 . */
38286 #line 1645 "../../libpoke/pvm.jitter"
38287 
38288     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
38289                                        (int) JITTER_ARGN0,
38290                                        (int) JITTER_ARGN1));
38291 
38292     /* End of the user code for pushvar/nR/n3 . */
38293 
38294 /* User-specified code, instruction-end-c part: beginning. */
38295 
38296 /* User-specified code, instruction-end-c part: end */
38297 
38298     /* Undefine the pushvar/nR/n3 argument macros so they can't be used
38299        by mistake in the instruction body coming next. */
38300 #   undef JITTER_SLOW_REGISTER_OFFSET0
38301 #   undef JITTER_ARG0
38302 #   undef JITTER_ARGN0
38303 #   undef JITTER_ARGU0
38304 #   undef JITTER_ARGP0
38305 #   undef JITTER_ARGF0
38306 #   undef JITTER_SLOW_REGISTER_OFFSET1
38307 #   undef JITTER_ARG1
38308 #   undef JITTER_ARGN1
38309 #   undef JITTER_ARGU1
38310 #   undef JITTER_ARGP1
38311 #   undef JITTER_ARGF1
38312 
38313 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38314 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38315 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38316 
38317   }
38318  JITTER_INSTRUCTION_EPILOG_(pushvar/nR/n3, pushvar__nR__n3, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38319 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38320 
38321   JITTER_INSTRUCTION_PROLOG_(pushvar/nR/n4, pushvar__nR__n4, cold)
38322   {
38323     /* This specialized instruction is not a replacement. */
38324 #   undef JITTER_BRANCH_FAST
38325 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38326 #   undef JITTER_BRANCH_FAST_IF_ZERO
38327 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38328 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38329 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38330 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38331 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38332 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38333 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38334 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38335 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38336 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38337 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38338 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38339 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38340 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38341 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38342 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38343 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38344 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38345 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38346 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38347 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38348 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38349 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38350 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38351 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38352 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38353 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38354 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38355 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38356 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38357 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38358 #   undef JITTER_BRANCH_FAST_IF_AND
38359 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38360 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38361 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38362 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38363 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38364 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38365 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38366 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38367 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38368 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38369 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38370 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38371 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38372 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38373 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38374 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38375 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38376 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38377 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38378 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38379 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38380 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38381 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38382 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38383 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38384 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38385 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38386 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38387 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38388 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       264
38389 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/nR/n4
38390 
38391 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__nR__n4
38392 
38393   /* The residual arity for this instruction does not depend on fast labels. */
38394   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
38395 
38396     /* The 0th argument is a residual literal. */
38397 #if defined(JITTER_DISPATCH_NO_THREADING)
38398 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38399     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38400 #elif defined (JITTER_REPLICATE)
38401 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38402 #else
38403 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38404 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38405 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38406 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38407 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38408 #   define JITTER_ARGF0 JITTER_ARGP0
38409 
38410     /* The 1th argument is a nonresidual literal. */
38411 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
38412 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
38413 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
38414 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
38415 #   define JITTER_ARGF1 JITTER_ARGP1
38416 
38417 
38418 #if defined (JITTER_PROFILE_SAMPLE)
38419   JITTER_PROFILE_SAMPLE_UPDATE
38420      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38421       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38422   /* Force the compiler not move sample-profiling instrumentation
38423      beyond this point; this way the actual user code is timed.
38424      This is still not perfect, as residuals are materialised before
38425      we arrive here, but should be adequate at least for slow VM
38426      instructions. */
38427   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38428 #endif
38429 #if defined (JITTER_PROFILE_COUNT)
38430   /* Notice that, differently from the code above, this
38431      instrumentation code *can* be reordered freely: as long as a
38432      VM instruction is counted, the count increment can be placed
38433      anyehere.  Let GCC move this code and possibly achieve better
38434      throughput by exploiting instruction-level parallelism and
38435      therefore approximate more closely a non-profiled build. */
38436   JITTER_PROFILE_COUNT_UPDATE
38437      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38438       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38439 #endif
38440 
38441 /* User-specified code, instruction-beginning-c part: beginning. */
38442 
38443 /* User-specified code, instruction-beginning-c part: end */
38444 
38445 
38446     /* User code for pushvar/nR/n4 . */
38447 #line 1645 "../../libpoke/pvm.jitter"
38448 
38449     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
38450                                        (int) JITTER_ARGN0,
38451                                        (int) JITTER_ARGN1));
38452 
38453     /* End of the user code for pushvar/nR/n4 . */
38454 
38455 /* User-specified code, instruction-end-c part: beginning. */
38456 
38457 /* User-specified code, instruction-end-c part: end */
38458 
38459     /* Undefine the pushvar/nR/n4 argument macros so they can't be used
38460        by mistake in the instruction body coming next. */
38461 #   undef JITTER_SLOW_REGISTER_OFFSET0
38462 #   undef JITTER_ARG0
38463 #   undef JITTER_ARGN0
38464 #   undef JITTER_ARGU0
38465 #   undef JITTER_ARGP0
38466 #   undef JITTER_ARGF0
38467 #   undef JITTER_SLOW_REGISTER_OFFSET1
38468 #   undef JITTER_ARG1
38469 #   undef JITTER_ARGN1
38470 #   undef JITTER_ARGU1
38471 #   undef JITTER_ARGP1
38472 #   undef JITTER_ARGF1
38473 
38474 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38475 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38476 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38477 
38478   }
38479  JITTER_INSTRUCTION_EPILOG_(pushvar/nR/n4, pushvar__nR__n4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38480 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38481 
38482   JITTER_INSTRUCTION_PROLOG_(pushvar/nR/n5, pushvar__nR__n5, cold)
38483   {
38484     /* This specialized instruction is not a replacement. */
38485 #   undef JITTER_BRANCH_FAST
38486 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38487 #   undef JITTER_BRANCH_FAST_IF_ZERO
38488 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38489 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38490 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38491 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38492 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38493 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38494 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38495 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38496 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38497 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38498 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38499 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38500 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38501 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38502 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38503 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38504 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38505 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38506 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38507 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38508 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38509 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38510 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38511 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38512 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38513 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38514 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38515 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38516 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38517 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38518 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38519 #   undef JITTER_BRANCH_FAST_IF_AND
38520 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38521 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38522 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38523 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38524 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38525 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38526 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38527 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38528 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38529 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38530 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38531 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38532 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38533 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38534 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38535 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38536 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38537 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38538 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38539 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38540 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38541 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38542 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38543 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38544 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38545 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38546 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38547 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38548 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38549 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       265
38550 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/nR/n5
38551 
38552 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__nR__n5
38553 
38554   /* The residual arity for this instruction does not depend on fast labels. */
38555   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
38556 
38557     /* The 0th argument is a residual literal. */
38558 #if defined(JITTER_DISPATCH_NO_THREADING)
38559 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38560     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38561 #elif defined (JITTER_REPLICATE)
38562 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38563 #else
38564 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38565 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38566 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38567 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38568 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38569 #   define JITTER_ARGF0 JITTER_ARGP0
38570 
38571     /* The 1th argument is a nonresidual literal. */
38572 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 5L})
38573 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
38574 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
38575 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
38576 #   define JITTER_ARGF1 JITTER_ARGP1
38577 
38578 
38579 #if defined (JITTER_PROFILE_SAMPLE)
38580   JITTER_PROFILE_SAMPLE_UPDATE
38581      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38582       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38583   /* Force the compiler not move sample-profiling instrumentation
38584      beyond this point; this way the actual user code is timed.
38585      This is still not perfect, as residuals are materialised before
38586      we arrive here, but should be adequate at least for slow VM
38587      instructions. */
38588   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38589 #endif
38590 #if defined (JITTER_PROFILE_COUNT)
38591   /* Notice that, differently from the code above, this
38592      instrumentation code *can* be reordered freely: as long as a
38593      VM instruction is counted, the count increment can be placed
38594      anyehere.  Let GCC move this code and possibly achieve better
38595      throughput by exploiting instruction-level parallelism and
38596      therefore approximate more closely a non-profiled build. */
38597   JITTER_PROFILE_COUNT_UPDATE
38598      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38599       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38600 #endif
38601 
38602 /* User-specified code, instruction-beginning-c part: beginning. */
38603 
38604 /* User-specified code, instruction-beginning-c part: end */
38605 
38606 
38607     /* User code for pushvar/nR/n5 . */
38608 #line 1645 "../../libpoke/pvm.jitter"
38609 
38610     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
38611                                        (int) JITTER_ARGN0,
38612                                        (int) JITTER_ARGN1));
38613 
38614     /* End of the user code for pushvar/nR/n5 . */
38615 
38616 /* User-specified code, instruction-end-c part: beginning. */
38617 
38618 /* User-specified code, instruction-end-c part: end */
38619 
38620     /* Undefine the pushvar/nR/n5 argument macros so they can't be used
38621        by mistake in the instruction body coming next. */
38622 #   undef JITTER_SLOW_REGISTER_OFFSET0
38623 #   undef JITTER_ARG0
38624 #   undef JITTER_ARGN0
38625 #   undef JITTER_ARGU0
38626 #   undef JITTER_ARGP0
38627 #   undef JITTER_ARGF0
38628 #   undef JITTER_SLOW_REGISTER_OFFSET1
38629 #   undef JITTER_ARG1
38630 #   undef JITTER_ARGN1
38631 #   undef JITTER_ARGU1
38632 #   undef JITTER_ARGP1
38633 #   undef JITTER_ARGF1
38634 
38635 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38636 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38637 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38638 
38639   }
38640  JITTER_INSTRUCTION_EPILOG_(pushvar/nR/n5, pushvar__nR__n5, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38641 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38642 
38643   JITTER_INSTRUCTION_PROLOG_(pushvar/nR/nR, pushvar__nR__nR, cold)
38644   {
38645     /* This specialized instruction is not a replacement. */
38646 #   undef JITTER_BRANCH_FAST
38647 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38648 #   undef JITTER_BRANCH_FAST_IF_ZERO
38649 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38650 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38651 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38652 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38653 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38654 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38655 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38656 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38657 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38658 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38659 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38660 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38661 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38662 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38663 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38664 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38665 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38666 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38667 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38668 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38669 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38670 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38671 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38672 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38673 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38674 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38675 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38676 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38677 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38678 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38679 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38680 #   undef JITTER_BRANCH_FAST_IF_AND
38681 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38682 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38683 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38684 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38685 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38686 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38687 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38688 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38689 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38690 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38691 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38692 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38693 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38694 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38695 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38696 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38697 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38698 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38699 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38700 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38701 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38702 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38703 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38704 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38705 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38706 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38707 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38708 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38709 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38710 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       266
38711 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pushvar/nR/nR
38712 
38713 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pushvar__nR__nR
38714 
38715   /* The residual arity for this instruction does not depend on fast labels. */
38716   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
38717 
38718     /* The 0th argument is a residual literal. */
38719 #if defined(JITTER_DISPATCH_NO_THREADING)
38720 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38721     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38722 #elif defined (JITTER_REPLICATE)
38723 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38724 #else
38725 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38726 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38727 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38728 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38729 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38730 #   define JITTER_ARGF0 JITTER_ARGP0
38731 
38732     /* The 1th argument is a residual literal. */
38733 #if defined(JITTER_DISPATCH_NO_THREADING)
38734 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
38735     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
38736 #elif defined (JITTER_REPLICATE)
38737 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
38738 #else
38739 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
38740 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38741 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
38742 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
38743 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
38744 #   define JITTER_ARGF1 JITTER_ARGP1
38745 
38746 
38747 #if defined (JITTER_PROFILE_SAMPLE)
38748   JITTER_PROFILE_SAMPLE_UPDATE
38749      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38750       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38751   /* Force the compiler not move sample-profiling instrumentation
38752      beyond this point; this way the actual user code is timed.
38753      This is still not perfect, as residuals are materialised before
38754      we arrive here, but should be adequate at least for slow VM
38755      instructions. */
38756   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38757 #endif
38758 #if defined (JITTER_PROFILE_COUNT)
38759   /* Notice that, differently from the code above, this
38760      instrumentation code *can* be reordered freely: as long as a
38761      VM instruction is counted, the count increment can be placed
38762      anyehere.  Let GCC move this code and possibly achieve better
38763      throughput by exploiting instruction-level parallelism and
38764      therefore approximate more closely a non-profiled build. */
38765   JITTER_PROFILE_COUNT_UPDATE
38766      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38767       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38768 #endif
38769 
38770 /* User-specified code, instruction-beginning-c part: beginning. */
38771 
38772 /* User-specified code, instruction-beginning-c part: end */
38773 
38774 
38775     /* User code for pushvar/nR/nR . */
38776 #line 1645 "../../libpoke/pvm.jitter"
38777 
38778     JITTER_PUSH_STACK (pvm_env_lookup (jitter_state_runtime.env,
38779                                        (int) JITTER_ARGN0,
38780                                        (int) JITTER_ARGN1));
38781 
38782     /* End of the user code for pushvar/nR/nR . */
38783 
38784 /* User-specified code, instruction-end-c part: beginning. */
38785 
38786 /* User-specified code, instruction-end-c part: end */
38787 
38788     /* Undefine the pushvar/nR/nR argument macros so they can't be used
38789        by mistake in the instruction body coming next. */
38790 #   undef JITTER_SLOW_REGISTER_OFFSET0
38791 #   undef JITTER_ARG0
38792 #   undef JITTER_ARGN0
38793 #   undef JITTER_ARGU0
38794 #   undef JITTER_ARGP0
38795 #   undef JITTER_ARGF0
38796 #   undef JITTER_SLOW_REGISTER_OFFSET1
38797 #   undef JITTER_ARG1
38798 #   undef JITTER_ARGN1
38799 #   undef JITTER_ARGU1
38800 #   undef JITTER_ARGP1
38801 #   undef JITTER_ARGF1
38802 
38803 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38804 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38805 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38806 
38807   }
38808  JITTER_INSTRUCTION_EPILOG_(pushvar/nR/nR, pushvar__nR__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38809 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38810 
38811   JITTER_INSTRUCTION_PROLOG_(quake, quake, hot)
38812   {
38813     /* This specialized instruction is not a replacement. */
38814 #   undef JITTER_BRANCH_FAST
38815 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38816 #   undef JITTER_BRANCH_FAST_IF_ZERO
38817 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38818 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38819 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38820 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38821 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38822 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38823 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38824 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38825 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38826 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38827 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38828 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38829 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38830 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38831 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38832 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38833 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38834 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38835 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38836 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38837 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38838 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38839 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38840 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38841 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38842 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38843 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38844 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38845 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38846 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38847 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38848 #   undef JITTER_BRANCH_FAST_IF_AND
38849 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38850 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38851 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38852 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38853 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38854 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38855 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38856 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38857 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38858 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38859 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38860 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38861 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38862 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38863 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38864 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38865 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38866 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38867 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38868 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38869 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38870 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38871 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38872 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38873 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38874 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38875 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38876 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38877 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38878 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       267
38879 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         quake
38880 
38881 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME quake
38882 
38883   /* The residual arity for this instruction does not depend on fast labels. */
38884   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
38885 
38886 
38887 #if defined (JITTER_PROFILE_SAMPLE)
38888   JITTER_PROFILE_SAMPLE_UPDATE
38889      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38890       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38891   /* Force the compiler not move sample-profiling instrumentation
38892      beyond this point; this way the actual user code is timed.
38893      This is still not perfect, as residuals are materialised before
38894      we arrive here, but should be adequate at least for slow VM
38895      instructions. */
38896   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38897 #endif
38898 #if defined (JITTER_PROFILE_COUNT)
38899   /* Notice that, differently from the code above, this
38900      instrumentation code *can* be reordered freely: as long as a
38901      VM instruction is counted, the count increment can be placed
38902      anyehere.  Let GCC move this code and possibly achieve better
38903      throughput by exploiting instruction-level parallelism and
38904      therefore approximate more closely a non-profiled build. */
38905   JITTER_PROFILE_COUNT_UPDATE
38906      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38907       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38908 #endif
38909 
38910 /* User-specified code, instruction-beginning-c part: beginning. */
38911 
38912 /* User-specified code, instruction-beginning-c part: end */
38913 
38914 
38915     /* User code for quake . */
38916 #line 2100 "../../libpoke/pvm.jitter"
38917 
38918     JITTER_QUAKE_STACK ();
38919 
38920     /* End of the user code for quake . */
38921 
38922 /* User-specified code, instruction-end-c part: beginning. */
38923 
38924 /* User-specified code, instruction-end-c part: end */
38925 
38926     /* Undefine the quake argument macros so they can't be used
38927        by mistake in the instruction body coming next. */
38928 
38929 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38930 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38931 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38932 
38933   }
38934  JITTER_INSTRUCTION_EPILOG_(quake, quake, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38935 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38936 
38937   JITTER_INSTRUCTION_PROLOG_(raise, raise, hot)
38938   {
38939     /* This specialized instruction is not a replacement. */
38940 #   undef JITTER_BRANCH_FAST
38941 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38942 #   undef JITTER_BRANCH_FAST_IF_ZERO
38943 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38944 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38945 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38946 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38947 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38948 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38949 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38950 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38951 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38952 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38953 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38954 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38955 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38956 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38957 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38958 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38959 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38960 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38961 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38962 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38963 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38964 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38965 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38966 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38967 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38968 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38969 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38970 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38971 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38972 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38973 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38974 #   undef JITTER_BRANCH_FAST_IF_AND
38975 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38976 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38977 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38978 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38979 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38980 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38981 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38982 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38983 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38984 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38985 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38986 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38987 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38988 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38989 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38990 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38991 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38992 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38993 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38994 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38995 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38996 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38997 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38998 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38999 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39000 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39001 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39002 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39003 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39004 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       268
39005 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         raise
39006 
39007 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME raise
39008 
39009   /* The residual arity for this instruction does not depend on fast labels. */
39010   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
39011 
39012 
39013 #if defined (JITTER_PROFILE_SAMPLE)
39014   JITTER_PROFILE_SAMPLE_UPDATE
39015      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39016       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39017   /* Force the compiler not move sample-profiling instrumentation
39018      beyond this point; this way the actual user code is timed.
39019      This is still not perfect, as residuals are materialised before
39020      we arrive here, but should be adequate at least for slow VM
39021      instructions. */
39022   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39023 #endif
39024 #if defined (JITTER_PROFILE_COUNT)
39025   /* Notice that, differently from the code above, this
39026      instrumentation code *can* be reordered freely: as long as a
39027      VM instruction is counted, the count increment can be placed
39028      anyehere.  Let GCC move this code and possibly achieve better
39029      throughput by exploiting instruction-level parallelism and
39030      therefore approximate more closely a non-profiled build. */
39031   JITTER_PROFILE_COUNT_UPDATE
39032      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39033       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39034 #endif
39035 
39036 /* User-specified code, instruction-beginning-c part: beginning. */
39037 
39038 /* User-specified code, instruction-beginning-c part: end */
39039 
39040 
39041     /* User code for raise . */
39042 #line 5596 "../../libpoke/pvm.jitter"
39043 
39044     pvm_val exception = JITTER_TOP_STACK ();
39045     JITTER_DROP_STACK ();
39046     PVM_RAISE_DIRECT (exception);
39047 
39048     /* End of the user code for raise . */
39049 
39050 /* User-specified code, instruction-end-c part: beginning. */
39051 
39052 /* User-specified code, instruction-end-c part: end */
39053 
39054     /* Undefine the raise argument macros so they can't be used
39055        by mistake in the instruction body coming next. */
39056 
39057 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39058 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39059 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39060 
39061   }
39062  JITTER_INSTRUCTION_EPILOG_(raise, raise, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39063 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39064 
39065   JITTER_INSTRUCTION_PROLOG_(rand, rand, hot)
39066   {
39067     /* This specialized instruction is not a replacement. */
39068 #   undef JITTER_BRANCH_FAST
39069 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
39070 #   undef JITTER_BRANCH_FAST_IF_ZERO
39071 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
39072 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39073 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
39074 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39075 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
39076 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39077 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
39078 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39079 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
39080 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39081 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
39082 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39083 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
39084 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39085 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
39086 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39087 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
39088 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39089 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39090 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39091 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39092 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39093 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39094 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39095 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39096 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39097 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39098 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39099 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39100 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39101 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39102 #   undef JITTER_BRANCH_FAST_IF_AND
39103 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
39104 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39105 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
39106 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39107 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39108 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39109 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39110 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39111 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39112 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39113 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39114 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39115 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39116 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39117 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39118 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39119 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39120 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39121 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39122 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39123 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39124 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39125 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39126 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39127 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39128 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39129 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39130 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39131 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39132 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       269
39133 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         rand
39134 
39135 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME rand
39136 
39137   /* The residual arity for this instruction does not depend on fast labels. */
39138   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
39139 
39140 
39141 #if defined (JITTER_PROFILE_SAMPLE)
39142   JITTER_PROFILE_SAMPLE_UPDATE
39143      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39144       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39145   /* Force the compiler not move sample-profiling instrumentation
39146      beyond this point; this way the actual user code is timed.
39147      This is still not perfect, as residuals are materialised before
39148      we arrive here, but should be adequate at least for slow VM
39149      instructions. */
39150   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39151 #endif
39152 #if defined (JITTER_PROFILE_COUNT)
39153   /* Notice that, differently from the code above, this
39154      instrumentation code *can* be reordered freely: as long as a
39155      VM instruction is counted, the count increment can be placed
39156      anyehere.  Let GCC move this code and possibly achieve better
39157      throughput by exploiting instruction-level parallelism and
39158      therefore approximate more closely a non-profiled build. */
39159   JITTER_PROFILE_COUNT_UPDATE
39160      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39161       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39162 #endif
39163 
39164 /* User-specified code, instruction-beginning-c part: beginning. */
39165 
39166 /* User-specified code, instruction-beginning-c part: end */
39167 
39168 
39169     /* User code for rand . */
39170 #line 5721 "../../libpoke/pvm.jitter"
39171 
39172     unsigned int seed = PVM_VAL_UINT (JITTER_TOP_STACK ());
39173 
39174     if (seed != 0)
39175       srandom (seed);
39176     JITTER_DROP_STACK ();
39177     JITTER_PUSH_STACK (PVM_MAKE_INT (random (), 32));
39178 
39179     /* End of the user code for rand . */
39180 
39181 /* User-specified code, instruction-end-c part: beginning. */
39182 
39183 /* User-specified code, instruction-end-c part: end */
39184 
39185     /* Undefine the rand argument macros so they can't be used
39186        by mistake in the instruction body coming next. */
39187 
39188 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39189 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39190 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39191 
39192   }
39193  JITTER_INSTRUCTION_EPILOG_(rand, rand, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39194 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39195 
39196   JITTER_INSTRUCTION_PROLOG_(regvar, regvar, hot)
39197   {
39198     /* This specialized instruction is not a replacement. */
39199 #   undef JITTER_BRANCH_FAST
39200 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
39201 #   undef JITTER_BRANCH_FAST_IF_ZERO
39202 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
39203 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39204 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
39205 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39206 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
39207 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39208 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
39209 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39210 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
39211 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39212 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
39213 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39214 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
39215 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39216 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
39217 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39218 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
39219 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39220 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39221 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39222 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39223 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39224 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39225 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39226 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39227 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39228 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39229 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39230 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39231 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39232 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39233 #   undef JITTER_BRANCH_FAST_IF_AND
39234 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
39235 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39236 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
39237 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39238 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39239 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39240 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39241 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39242 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39243 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39244 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39245 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39246 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39247 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39248 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39249 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39250 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39251 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39252 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39253 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39254 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39255 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39256 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39257 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39258 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39259 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39260 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39261 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39262 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39263 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       270
39264 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         regvar
39265 
39266 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME regvar
39267 
39268   /* The residual arity for this instruction does not depend on fast labels. */
39269   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
39270 
39271 
39272 #if defined (JITTER_PROFILE_SAMPLE)
39273   JITTER_PROFILE_SAMPLE_UPDATE
39274      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39275       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39276   /* Force the compiler not move sample-profiling instrumentation
39277      beyond this point; this way the actual user code is timed.
39278      This is still not perfect, as residuals are materialised before
39279      we arrive here, but should be adequate at least for slow VM
39280      instructions. */
39281   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39282 #endif
39283 #if defined (JITTER_PROFILE_COUNT)
39284   /* Notice that, differently from the code above, this
39285      instrumentation code *can* be reordered freely: as long as a
39286      VM instruction is counted, the count increment can be placed
39287      anyehere.  Let GCC move this code and possibly achieve better
39288      throughput by exploiting instruction-level parallelism and
39289      therefore approximate more closely a non-profiled build. */
39290   JITTER_PROFILE_COUNT_UPDATE
39291      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39292       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39293 #endif
39294 
39295 /* User-specified code, instruction-beginning-c part: beginning. */
39296 
39297 /* User-specified code, instruction-beginning-c part: end */
39298 
39299 
39300     /* User code for regvar . */
39301 #line 1703 "../../libpoke/pvm.jitter"
39302 
39303     pvm_env_register (jitter_state_runtime.env,
39304                       JITTER_TOP_STACK ());
39305     JITTER_DROP_STACK ();
39306 
39307     /* End of the user code for regvar . */
39308 
39309 /* User-specified code, instruction-end-c part: beginning. */
39310 
39311 /* User-specified code, instruction-end-c part: end */
39312 
39313     /* Undefine the regvar argument macros so they can't be used
39314        by mistake in the instruction body coming next. */
39315 
39316 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39317 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39318 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39319 
39320   }
39321  JITTER_INSTRUCTION_EPILOG_(regvar, regvar, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39322 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39323 
39324   JITTER_INSTRUCTION_PROLOG_(reloc, reloc, hot)
39325   {
39326     /* This specialized instruction is not a replacement. */
39327 #   undef JITTER_BRANCH_FAST
39328 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
39329 #   undef JITTER_BRANCH_FAST_IF_ZERO
39330 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
39331 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39332 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
39333 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39334 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
39335 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39336 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
39337 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39338 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
39339 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39340 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
39341 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39342 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
39343 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39344 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
39345 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39346 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
39347 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39348 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39349 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39350 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39351 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39352 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39353 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39354 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39355 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39356 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39357 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39358 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39359 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39360 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39361 #   undef JITTER_BRANCH_FAST_IF_AND
39362 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
39363 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39364 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
39365 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39366 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39367 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39368 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39369 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39370 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39371 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39372 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39373 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39374 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39375 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39376 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39377 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39378 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39379 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39380 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39381 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39382 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39383 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39384 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39385 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39386 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39387 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39388 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39389 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39390 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39391 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       271
39392 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         reloc
39393 
39394 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME reloc
39395 
39396   /* The residual arity for this instruction does not depend on fast labels. */
39397   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
39398 
39399 
39400 #if defined (JITTER_PROFILE_SAMPLE)
39401   JITTER_PROFILE_SAMPLE_UPDATE
39402      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39403       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39404   /* Force the compiler not move sample-profiling instrumentation
39405      beyond this point; this way the actual user code is timed.
39406      This is still not perfect, as residuals are materialised before
39407      we arrive here, but should be adequate at least for slow VM
39408      instructions. */
39409   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39410 #endif
39411 #if defined (JITTER_PROFILE_COUNT)
39412   /* Notice that, differently from the code above, this
39413      instrumentation code *can* be reordered freely: as long as a
39414      VM instruction is counted, the count increment can be placed
39415      anyehere.  Let GCC move this code and possibly achieve better
39416      throughput by exploiting instruction-level parallelism and
39417      therefore approximate more closely a non-profiled build. */
39418   JITTER_PROFILE_COUNT_UPDATE
39419      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39420       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39421 #endif
39422 
39423 /* User-specified code, instruction-beginning-c part: beginning. */
39424 
39425 /* User-specified code, instruction-beginning-c part: end */
39426 
39427 
39428     /* User code for reloc . */
39429 #line 4716 "../../libpoke/pvm.jitter"
39430 
39431     pvm_val boffset = JITTER_TOP_STACK ();
39432     pvm_val ios = JITTER_UNDER_TOP_STACK ();
39433     pvm_val val;
39434 
39435     JITTER_DROP_STACK ();
39436     val = JITTER_UNDER_TOP_STACK ();
39437     JITTER_PUSH_STACK (boffset);
39438 
39439     if (!(PVM_IS_ARR (val) || PVM_IS_SCT (val)))
39440       PVM_RAISE_DFL (PVM_E_INVAL);
39441 
39442     pvm_val_reloc (val, ios, boffset);
39443 
39444     /* End of the user code for reloc . */
39445 
39446 /* User-specified code, instruction-end-c part: beginning. */
39447 
39448 /* User-specified code, instruction-end-c part: end */
39449 
39450     /* Undefine the reloc argument macros so they can't be used
39451        by mistake in the instruction body coming next. */
39452 
39453 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39454 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39455 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39456 
39457   }
39458  JITTER_INSTRUCTION_EPILOG_(reloc, reloc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39459 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39460 
39461   JITTER_INSTRUCTION_PROLOG_(restorer/%rR, restorer___rrR, cold)
39462   {
39463     /* This specialized instruction is not a replacement. */
39464 #   undef JITTER_BRANCH_FAST
39465 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
39466 #   undef JITTER_BRANCH_FAST_IF_ZERO
39467 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
39468 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39469 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
39470 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39471 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
39472 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39473 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
39474 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39475 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
39476 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39477 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
39478 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39479 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
39480 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39481 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
39482 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39483 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
39484 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39485 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39486 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39487 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39488 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39489 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39490 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39491 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39492 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39493 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39494 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39495 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39496 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39497 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39498 #   undef JITTER_BRANCH_FAST_IF_AND
39499 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
39500 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39501 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
39502 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39503 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39504 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39505 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39506 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39507 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39508 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39509 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39510 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39511 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39512 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39513 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39514 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39515 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39516 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39517 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39518 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39519 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39520 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39521 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39522 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39523 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39524 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39525 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39526 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39527 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39528 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       272
39529 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         restorer/%rR
39530 
39531 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME restorer___rrR
39532 
39533   /* The residual arity for this instruction does not depend on fast labels. */
39534   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
39535 
39536     /* The 0th argument is a slow (therefore residual, passed as an offset)
39537         register. */
39538   /* Define a macro expanding to the slow register offset. */
39539 #if defined(JITTER_DISPATCH_NO_THREADING)
39540 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
39541 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
39542 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
39543 #else
39544 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
39545 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39546   /* Define a macro expanding to an l-value for the VM register content. */
39547 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
39548 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39549 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39550 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39551 #   define JITTER_ARGF0 JITTER_ARGP0
39552 
39553 
39554 #if defined (JITTER_PROFILE_SAMPLE)
39555   JITTER_PROFILE_SAMPLE_UPDATE
39556      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39557       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39558   /* Force the compiler not move sample-profiling instrumentation
39559      beyond this point; this way the actual user code is timed.
39560      This is still not perfect, as residuals are materialised before
39561      we arrive here, but should be adequate at least for slow VM
39562      instructions. */
39563   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39564 #endif
39565 #if defined (JITTER_PROFILE_COUNT)
39566   /* Notice that, differently from the code above, this
39567      instrumentation code *can* be reordered freely: as long as a
39568      VM instruction is counted, the count increment can be placed
39569      anyehere.  Let GCC move this code and possibly achieve better
39570      throughput by exploiting instruction-level parallelism and
39571      therefore approximate more closely a non-profiled build. */
39572   JITTER_PROFILE_COUNT_UPDATE
39573      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39574       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39575 #endif
39576 
39577 /* User-specified code, instruction-beginning-c part: beginning. */
39578 
39579 /* User-specified code, instruction-beginning-c part: end */
39580 
39581 
39582     /* User code for restorer/%rR . */
39583 #line 2235 "../../libpoke/pvm.jitter"
39584 
39585     JITTER_ARG0 = JITTER_TOP_RETURNSTACK ();
39586     JITTER_DROP_RETURNSTACK ();
39587 
39588     /* End of the user code for restorer/%rR . */
39589 
39590 /* User-specified code, instruction-end-c part: beginning. */
39591 
39592 /* User-specified code, instruction-end-c part: end */
39593 
39594     /* Undefine the restorer/%rR argument macros so they can't be used
39595        by mistake in the instruction body coming next. */
39596 #   undef JITTER_SLOW_REGISTER_OFFSET0
39597 #   undef JITTER_ARG0
39598 #   undef JITTER_ARGN0
39599 #   undef JITTER_ARGU0
39600 #   undef JITTER_ARGP0
39601 #   undef JITTER_ARGF0
39602 
39603 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39604 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39605 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39606 
39607   }
39608  JITTER_INSTRUCTION_EPILOG_(restorer/%rR, restorer___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39609 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39610 
39611   JITTER_INSTRUCTION_PROLOG_(return, return, hot)
39612   {
39613     /* This specialized instruction is not a replacement. */
39614 #   undef JITTER_BRANCH_FAST
39615 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
39616 #   undef JITTER_BRANCH_FAST_IF_ZERO
39617 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
39618 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39619 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
39620 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39621 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
39622 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39623 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
39624 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39625 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
39626 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39627 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
39628 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39629 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
39630 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39631 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
39632 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39633 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
39634 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39635 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39636 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39637 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39638 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39639 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39640 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39641 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39642 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39643 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39644 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39645 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39646 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39647 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39648 #   undef JITTER_BRANCH_FAST_IF_AND
39649 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
39650 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39651 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
39652 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39653 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39654 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39655 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39656 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39657 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39658 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39659 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39660 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39661 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39662 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39663 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39664 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39665 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39666 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39667 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39668 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39669 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39670 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39671 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39672 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39673 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39674 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39675 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39676 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39677 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39678 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       273
39679 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         return
39680 
39681 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME return
39682 
39683   /* The residual arity for this instruction does not depend on fast labels. */
39684   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
39685 
39686 
39687 #if defined (JITTER_PROFILE_SAMPLE)
39688   JITTER_PROFILE_SAMPLE_UPDATE
39689      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39690       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39691   /* Force the compiler not move sample-profiling instrumentation
39692      beyond this point; this way the actual user code is timed.
39693      This is still not perfect, as residuals are materialised before
39694      we arrive here, but should be adequate at least for slow VM
39695      instructions. */
39696   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39697 #endif
39698 #if defined (JITTER_PROFILE_COUNT)
39699   /* Notice that, differently from the code above, this
39700      instrumentation code *can* be reordered freely: as long as a
39701      VM instruction is counted, the count increment can be placed
39702      anyehere.  Let GCC move this code and possibly achieve better
39703      throughput by exploiting instruction-level parallelism and
39704      therefore approximate more closely a non-profiled build. */
39705   JITTER_PROFILE_COUNT_UPDATE
39706      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39707       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39708 #endif
39709 
39710 /* User-specified code, instruction-beginning-c part: beginning. */
39711 
39712 /* User-specified code, instruction-beginning-c part: end */
39713 
39714 
39715     /* User code for return . */
39716 #line 1586 "../../libpoke/pvm.jitter"
39717 
39718     jitter_uint return_address;
39719 
39720     /* Restore the environment of the caller.  Note the cast to
39721        jitter_uint is to avoid a warning in 32-bit.  */
39722     jitter_state_runtime.env = (pvm_env) (jitter_int) JITTER_TOP_RETURNSTACK ();
39723     JITTER_DROP_RETURNSTACK();
39724 
39725     return_address = JITTER_TOP_RETURNSTACK();
39726     JITTER_DROP_RETURNSTACK();
39727 
39728     JITTER_RETURN (return_address);
39729 
39730     /* End of the user code for return . */
39731 
39732 /* User-specified code, instruction-end-c part: beginning. */
39733 
39734 /* User-specified code, instruction-end-c part: end */
39735 
39736     /* Undefine the return argument macros so they can't be used
39737        by mistake in the instruction body coming next. */
39738 
39739 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39740 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39741 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39742 
39743   }
39744  JITTER_INSTRUCTION_EPILOG_(return, return, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39745 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39746 
39747   JITTER_INSTRUCTION_PROLOG_(revn/n3, revn__n3, hot)
39748   {
39749     /* This specialized instruction is not a replacement. */
39750 #   undef JITTER_BRANCH_FAST
39751 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
39752 #   undef JITTER_BRANCH_FAST_IF_ZERO
39753 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
39754 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39755 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
39756 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39757 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
39758 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39759 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
39760 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39761 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
39762 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39763 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
39764 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39765 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
39766 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39767 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
39768 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39769 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
39770 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39771 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39772 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39773 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39774 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39775 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39776 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39777 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39778 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39779 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39780 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39781 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39782 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39783 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39784 #   undef JITTER_BRANCH_FAST_IF_AND
39785 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
39786 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39787 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
39788 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39789 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39790 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39791 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39792 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39793 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39794 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39795 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39796 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39797 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39798 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39799 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39800 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39801 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39802 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39803 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39804 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39805 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39806 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39807 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39808 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39809 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39810 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39811 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39812 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39813 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39814 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       274
39815 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         revn/n3
39816 
39817 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME revn__n3
39818 
39819   /* The residual arity for this instruction does not depend on fast labels. */
39820   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
39821 
39822     /* The 0th argument is a nonresidual literal. */
39823 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
39824 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39825 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39826 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39827 #   define JITTER_ARGF0 JITTER_ARGP0
39828 
39829 
39830 #if defined (JITTER_PROFILE_SAMPLE)
39831   JITTER_PROFILE_SAMPLE_UPDATE
39832      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39833       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39834   /* Force the compiler not move sample-profiling instrumentation
39835      beyond this point; this way the actual user code is timed.
39836      This is still not perfect, as residuals are materialised before
39837      we arrive here, but should be adequate at least for slow VM
39838      instructions. */
39839   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39840 #endif
39841 #if defined (JITTER_PROFILE_COUNT)
39842   /* Notice that, differently from the code above, this
39843      instrumentation code *can* be reordered freely: as long as a
39844      VM instruction is counted, the count increment can be placed
39845      anyehere.  Let GCC move this code and possibly achieve better
39846      throughput by exploiting instruction-level parallelism and
39847      therefore approximate more closely a non-profiled build. */
39848   JITTER_PROFILE_COUNT_UPDATE
39849      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39850       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39851 #endif
39852 
39853 /* User-specified code, instruction-beginning-c part: beginning. */
39854 
39855 /* User-specified code, instruction-beginning-c part: end */
39856 
39857 
39858     /* User code for revn/n3 . */
39859 #line 2112 "../../libpoke/pvm.jitter"
39860 
39861     JITTER_REVERSE_STACK (JITTER_ARGU0);
39862 
39863     /* End of the user code for revn/n3 . */
39864 
39865 /* User-specified code, instruction-end-c part: beginning. */
39866 
39867 /* User-specified code, instruction-end-c part: end */
39868 
39869     /* Undefine the revn/n3 argument macros so they can't be used
39870        by mistake in the instruction body coming next. */
39871 #   undef JITTER_SLOW_REGISTER_OFFSET0
39872 #   undef JITTER_ARG0
39873 #   undef JITTER_ARGN0
39874 #   undef JITTER_ARGU0
39875 #   undef JITTER_ARGP0
39876 #   undef JITTER_ARGF0
39877 
39878 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39879 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39880 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39881 
39882   }
39883  JITTER_INSTRUCTION_EPILOG_(revn/n3, revn__n3, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39884 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39885 
39886   JITTER_INSTRUCTION_PROLOG_(revn/n4, revn__n4, hot)
39887   {
39888     /* This specialized instruction is not a replacement. */
39889 #   undef JITTER_BRANCH_FAST
39890 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
39891 #   undef JITTER_BRANCH_FAST_IF_ZERO
39892 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
39893 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39894 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
39895 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39896 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
39897 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39898 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
39899 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39900 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
39901 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39902 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
39903 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39904 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
39905 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39906 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
39907 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39908 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
39909 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39910 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39911 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39912 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39913 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39914 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39915 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39916 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39917 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39918 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39919 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39920 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39921 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39922 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39923 #   undef JITTER_BRANCH_FAST_IF_AND
39924 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
39925 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39926 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
39927 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39928 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39929 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39930 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39931 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39932 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39933 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39934 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39935 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39936 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39937 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39938 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39939 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39940 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39941 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39942 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39943 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39944 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39945 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39946 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39947 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39948 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39949 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39950 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39951 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39952 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39953 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       275
39954 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         revn/n4
39955 
39956 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME revn__n4
39957 
39958   /* The residual arity for this instruction does not depend on fast labels. */
39959   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
39960 
39961     /* The 0th argument is a nonresidual literal. */
39962 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
39963 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39964 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39965 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39966 #   define JITTER_ARGF0 JITTER_ARGP0
39967 
39968 
39969 #if defined (JITTER_PROFILE_SAMPLE)
39970   JITTER_PROFILE_SAMPLE_UPDATE
39971      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39972       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39973   /* Force the compiler not move sample-profiling instrumentation
39974      beyond this point; this way the actual user code is timed.
39975      This is still not perfect, as residuals are materialised before
39976      we arrive here, but should be adequate at least for slow VM
39977      instructions. */
39978   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39979 #endif
39980 #if defined (JITTER_PROFILE_COUNT)
39981   /* Notice that, differently from the code above, this
39982      instrumentation code *can* be reordered freely: as long as a
39983      VM instruction is counted, the count increment can be placed
39984      anyehere.  Let GCC move this code and possibly achieve better
39985      throughput by exploiting instruction-level parallelism and
39986      therefore approximate more closely a non-profiled build. */
39987   JITTER_PROFILE_COUNT_UPDATE
39988      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39989       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39990 #endif
39991 
39992 /* User-specified code, instruction-beginning-c part: beginning. */
39993 
39994 /* User-specified code, instruction-beginning-c part: end */
39995 
39996 
39997     /* User code for revn/n4 . */
39998 #line 2112 "../../libpoke/pvm.jitter"
39999 
40000     JITTER_REVERSE_STACK (JITTER_ARGU0);
40001 
40002     /* End of the user code for revn/n4 . */
40003 
40004 /* User-specified code, instruction-end-c part: beginning. */
40005 
40006 /* User-specified code, instruction-end-c part: end */
40007 
40008     /* Undefine the revn/n4 argument macros so they can't be used
40009        by mistake in the instruction body coming next. */
40010 #   undef JITTER_SLOW_REGISTER_OFFSET0
40011 #   undef JITTER_ARG0
40012 #   undef JITTER_ARGN0
40013 #   undef JITTER_ARGU0
40014 #   undef JITTER_ARGP0
40015 #   undef JITTER_ARGF0
40016 
40017 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40018 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40019 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40020 
40021   }
40022  JITTER_INSTRUCTION_EPILOG_(revn/n4, revn__n4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40023 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40024 
40025   JITTER_INSTRUCTION_PROLOG_(revn/nR, revn__nR, cold)
40026   {
40027     /* This specialized instruction is not a replacement. */
40028 #   undef JITTER_BRANCH_FAST
40029 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40030 #   undef JITTER_BRANCH_FAST_IF_ZERO
40031 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40032 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40033 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40034 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40035 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40036 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40037 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40038 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40039 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40040 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40041 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
40042 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40043 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
40044 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40045 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
40046 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40047 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
40048 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40049 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40050 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40051 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40052 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40053 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40054 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40055 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40056 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40057 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40058 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40059 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40060 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40061 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40062 #   undef JITTER_BRANCH_FAST_IF_AND
40063 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
40064 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40065 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
40066 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40067 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40068 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40069 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40070 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40071 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40072 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40073 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40074 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40075 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40076 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40077 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40078 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40079 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40080 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40081 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40082 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40083 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40084 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40085 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40086 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40087 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40088 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40089 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40090 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40091 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40092 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       276
40093 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         revn/nR
40094 
40095 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME revn__nR
40096 
40097   /* The residual arity for this instruction does not depend on fast labels. */
40098   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
40099 
40100     /* The 0th argument is a residual literal. */
40101 #if defined(JITTER_DISPATCH_NO_THREADING)
40102 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
40103     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40104 #elif defined (JITTER_REPLICATE)
40105 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
40106 #else
40107 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
40108 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40109 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40110 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40111 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40112 #   define JITTER_ARGF0 JITTER_ARGP0
40113 
40114 
40115 #if defined (JITTER_PROFILE_SAMPLE)
40116   JITTER_PROFILE_SAMPLE_UPDATE
40117      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40118       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40119   /* Force the compiler not move sample-profiling instrumentation
40120      beyond this point; this way the actual user code is timed.
40121      This is still not perfect, as residuals are materialised before
40122      we arrive here, but should be adequate at least for slow VM
40123      instructions. */
40124   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40125 #endif
40126 #if defined (JITTER_PROFILE_COUNT)
40127   /* Notice that, differently from the code above, this
40128      instrumentation code *can* be reordered freely: as long as a
40129      VM instruction is counted, the count increment can be placed
40130      anyehere.  Let GCC move this code and possibly achieve better
40131      throughput by exploiting instruction-level parallelism and
40132      therefore approximate more closely a non-profiled build. */
40133   JITTER_PROFILE_COUNT_UPDATE
40134      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40135       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40136 #endif
40137 
40138 /* User-specified code, instruction-beginning-c part: beginning. */
40139 
40140 /* User-specified code, instruction-beginning-c part: end */
40141 
40142 
40143     /* User code for revn/nR . */
40144 #line 2112 "../../libpoke/pvm.jitter"
40145 
40146     JITTER_REVERSE_STACK (JITTER_ARGU0);
40147 
40148     /* End of the user code for revn/nR . */
40149 
40150 /* User-specified code, instruction-end-c part: beginning. */
40151 
40152 /* User-specified code, instruction-end-c part: end */
40153 
40154     /* Undefine the revn/nR argument macros so they can't be used
40155        by mistake in the instruction body coming next. */
40156 #   undef JITTER_SLOW_REGISTER_OFFSET0
40157 #   undef JITTER_ARG0
40158 #   undef JITTER_ARGN0
40159 #   undef JITTER_ARGU0
40160 #   undef JITTER_ARGP0
40161 #   undef JITTER_ARGF0
40162 
40163 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40164 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40165 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40166 
40167   }
40168  JITTER_INSTRUCTION_EPILOG_(revn/nR, revn__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40169 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40170 
40171   JITTER_INSTRUCTION_PROLOG_(rot, rot, hot)
40172   {
40173     /* This specialized instruction is not a replacement. */
40174 #   undef JITTER_BRANCH_FAST
40175 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40176 #   undef JITTER_BRANCH_FAST_IF_ZERO
40177 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40178 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40179 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40180 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40181 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40182 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40183 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40184 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40185 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40186 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40187 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
40188 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40189 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
40190 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40191 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
40192 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40193 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
40194 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40195 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40196 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40197 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40198 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40199 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40200 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40201 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40202 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40203 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40204 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40205 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40206 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40207 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40208 #   undef JITTER_BRANCH_FAST_IF_AND
40209 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
40210 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40211 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
40212 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40213 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40214 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40215 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40216 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40217 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40218 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40219 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40220 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40221 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40222 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40223 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40224 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40225 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40226 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40227 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40228 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40229 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40230 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40231 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40232 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40233 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40234 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40235 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40236 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40237 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40238 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       277
40239 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         rot
40240 
40241 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME rot
40242 
40243   /* The residual arity for this instruction does not depend on fast labels. */
40244   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
40245 
40246 
40247 #if defined (JITTER_PROFILE_SAMPLE)
40248   JITTER_PROFILE_SAMPLE_UPDATE
40249      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40250       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40251   /* Force the compiler not move sample-profiling instrumentation
40252      beyond this point; this way the actual user code is timed.
40253      This is still not perfect, as residuals are materialised before
40254      we arrive here, but should be adequate at least for slow VM
40255      instructions. */
40256   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40257 #endif
40258 #if defined (JITTER_PROFILE_COUNT)
40259   /* Notice that, differently from the code above, this
40260      instrumentation code *can* be reordered freely: as long as a
40261      VM instruction is counted, the count increment can be placed
40262      anyehere.  Let GCC move this code and possibly achieve better
40263      throughput by exploiting instruction-level parallelism and
40264      therefore approximate more closely a non-profiled build. */
40265   JITTER_PROFILE_COUNT_UPDATE
40266      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40267       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40268 #endif
40269 
40270 /* User-specified code, instruction-beginning-c part: beginning. */
40271 
40272 /* User-specified code, instruction-beginning-c part: end */
40273 
40274 
40275     /* User code for rot . */
40276 #line 2062 "../../libpoke/pvm.jitter"
40277 
40278     JITTER_ROT_STACK ();
40279 
40280     /* End of the user code for rot . */
40281 
40282 /* User-specified code, instruction-end-c part: beginning. */
40283 
40284 /* User-specified code, instruction-end-c part: end */
40285 
40286     /* Undefine the rot argument macros so they can't be used
40287        by mistake in the instruction body coming next. */
40288 
40289 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40290 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40291 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40292 
40293   }
40294  JITTER_INSTRUCTION_EPILOG_(rot, rot, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40295 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40296 
40297   JITTER_INSTRUCTION_PROLOG_(saver/%rR, saver___rrR, cold)
40298   {
40299     /* This specialized instruction is not a replacement. */
40300 #   undef JITTER_BRANCH_FAST
40301 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40302 #   undef JITTER_BRANCH_FAST_IF_ZERO
40303 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40304 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40305 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40306 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40307 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40308 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40309 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40310 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40311 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40312 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40313 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
40314 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40315 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
40316 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40317 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
40318 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40319 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
40320 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40321 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40322 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40323 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40324 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40325 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40326 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40327 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40328 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40329 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40330 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40331 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40332 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40333 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40334 #   undef JITTER_BRANCH_FAST_IF_AND
40335 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
40336 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40337 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
40338 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40339 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40340 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40341 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40342 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40343 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40344 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40345 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40346 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40347 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40348 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40349 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40350 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40351 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40352 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40353 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40354 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40355 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40356 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40357 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40358 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40359 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40360 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40361 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40362 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40363 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40364 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       278
40365 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         saver/%rR
40366 
40367 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME saver___rrR
40368 
40369   /* The residual arity for this instruction does not depend on fast labels. */
40370   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
40371 
40372     /* The 0th argument is a slow (therefore residual, passed as an offset)
40373         register. */
40374   /* Define a macro expanding to the slow register offset. */
40375 #if defined(JITTER_DISPATCH_NO_THREADING)
40376 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
40377 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
40378 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
40379 #else
40380 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
40381 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40382   /* Define a macro expanding to an l-value for the VM register content. */
40383 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
40384 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40385 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40386 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40387 #   define JITTER_ARGF0 JITTER_ARGP0
40388 
40389 
40390 #if defined (JITTER_PROFILE_SAMPLE)
40391   JITTER_PROFILE_SAMPLE_UPDATE
40392      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40393       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40394   /* Force the compiler not move sample-profiling instrumentation
40395      beyond this point; this way the actual user code is timed.
40396      This is still not perfect, as residuals are materialised before
40397      we arrive here, but should be adequate at least for slow VM
40398      instructions. */
40399   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40400 #endif
40401 #if defined (JITTER_PROFILE_COUNT)
40402   /* Notice that, differently from the code above, this
40403      instrumentation code *can* be reordered freely: as long as a
40404      VM instruction is counted, the count increment can be placed
40405      anyehere.  Let GCC move this code and possibly achieve better
40406      throughput by exploiting instruction-level parallelism and
40407      therefore approximate more closely a non-profiled build. */
40408   JITTER_PROFILE_COUNT_UPDATE
40409      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40410       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40411 #endif
40412 
40413 /* User-specified code, instruction-beginning-c part: beginning. */
40414 
40415 /* User-specified code, instruction-beginning-c part: end */
40416 
40417 
40418     /* User code for saver/%rR . */
40419 #line 2221 "../../libpoke/pvm.jitter"
40420 
40421     JITTER_PUSH_RETURNSTACK (JITTER_ARG0);
40422 
40423     /* End of the user code for saver/%rR . */
40424 
40425 /* User-specified code, instruction-end-c part: beginning. */
40426 
40427 /* User-specified code, instruction-end-c part: end */
40428 
40429     /* Undefine the saver/%rR argument macros so they can't be used
40430        by mistake in the instruction body coming next. */
40431 #   undef JITTER_SLOW_REGISTER_OFFSET0
40432 #   undef JITTER_ARG0
40433 #   undef JITTER_ARGN0
40434 #   undef JITTER_ARGU0
40435 #   undef JITTER_ARGP0
40436 #   undef JITTER_ARGF0
40437 
40438 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40439 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40440 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40441 
40442   }
40443  JITTER_INSTRUCTION_EPILOG_(saver/%rR, saver___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40444 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40445 
40446   JITTER_INSTRUCTION_PROLOG_(sconc, sconc, hot)
40447   {
40448     /* This specialized instruction is not a replacement. */
40449 #   undef JITTER_BRANCH_FAST
40450 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40451 #   undef JITTER_BRANCH_FAST_IF_ZERO
40452 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40453 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40454 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40455 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40456 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40457 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40458 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40459 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40460 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40461 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40462 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
40463 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40464 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
40465 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40466 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
40467 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40468 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
40469 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40470 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40471 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40472 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40473 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40474 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40475 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40476 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40477 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40478 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40479 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40480 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40481 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40482 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40483 #   undef JITTER_BRANCH_FAST_IF_AND
40484 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
40485 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40486 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
40487 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40488 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40489 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40490 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40491 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40492 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40493 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40494 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40495 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40496 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40497 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40498 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40499 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40500 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40501 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40502 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40503 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40504 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40505 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40506 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40507 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40508 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40509 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40510 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40511 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40512 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40513 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       279
40514 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         sconc
40515 
40516 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME sconc
40517 
40518   /* The residual arity for this instruction does not depend on fast labels. */
40519   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
40520 
40521 
40522 #if defined (JITTER_PROFILE_SAMPLE)
40523   JITTER_PROFILE_SAMPLE_UPDATE
40524      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40525       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40526   /* Force the compiler not move sample-profiling instrumentation
40527      beyond this point; this way the actual user code is timed.
40528      This is still not perfect, as residuals are materialised before
40529      we arrive here, but should be adequate at least for slow VM
40530      instructions. */
40531   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40532 #endif
40533 #if defined (JITTER_PROFILE_COUNT)
40534   /* Notice that, differently from the code above, this
40535      instrumentation code *can* be reordered freely: as long as a
40536      VM instruction is counted, the count increment can be placed
40537      anyehere.  Let GCC move this code and possibly achieve better
40538      throughput by exploiting instruction-level parallelism and
40539      therefore approximate more closely a non-profiled build. */
40540   JITTER_PROFILE_COUNT_UPDATE
40541      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40542       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40543 #endif
40544 
40545 /* User-specified code, instruction-beginning-c part: beginning. */
40546 
40547 /* User-specified code, instruction-beginning-c part: end */
40548 
40549 
40550     /* User code for sconc . */
40551 #line 3118 "../../libpoke/pvm.jitter"
40552 
40553      pvm_val res;
40554      char *sa = PVM_VAL_STR (JITTER_UNDER_TOP_STACK ());
40555      char *sb = PVM_VAL_STR (JITTER_TOP_STACK ());
40556      char *s = pvm_alloc (strlen (sa) + strlen (sb) + 1);
40557      strcpy (s, sa);
40558      strcat (s, sb);
40559      res = pvm_make_string (s);
40560 
40561      JITTER_PUSH_STACK (res);
40562 #undef F
40563 
40564     /* End of the user code for sconc . */
40565 
40566 /* User-specified code, instruction-end-c part: beginning. */
40567 
40568 /* User-specified code, instruction-end-c part: end */
40569 
40570     /* Undefine the sconc argument macros so they can't be used
40571        by mistake in the instruction body coming next. */
40572 
40573 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40574 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40575 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40576 
40577   }
40578  JITTER_INSTRUCTION_EPILOG_(sconc, sconc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40579 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40580 
40581   JITTER_INSTRUCTION_PROLOG_(sel, sel, hot)
40582   {
40583     /* This specialized instruction is not a replacement. */
40584 #   undef JITTER_BRANCH_FAST
40585 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40586 #   undef JITTER_BRANCH_FAST_IF_ZERO
40587 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40588 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40589 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40590 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40591 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40592 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40593 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40594 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40595 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40596 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40597 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
40598 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40599 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
40600 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40601 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
40602 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40603 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
40604 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40605 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40606 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40607 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40608 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40609 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40610 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40611 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40612 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40613 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40614 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40615 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40616 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40617 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40618 #   undef JITTER_BRANCH_FAST_IF_AND
40619 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
40620 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40621 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
40622 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40623 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40624 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40625 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40626 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40627 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40628 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40629 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40630 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40631 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40632 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40633 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40634 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40635 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40636 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40637 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40638 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40639 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40640 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40641 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40642 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40643 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40644 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40645 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40646 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40647 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40648 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       280
40649 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         sel
40650 
40651 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME sel
40652 
40653   /* The residual arity for this instruction does not depend on fast labels. */
40654   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
40655 
40656 
40657 #if defined (JITTER_PROFILE_SAMPLE)
40658   JITTER_PROFILE_SAMPLE_UPDATE
40659      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40660       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40661   /* Force the compiler not move sample-profiling instrumentation
40662      beyond this point; this way the actual user code is timed.
40663      This is still not perfect, as residuals are materialised before
40664      we arrive here, but should be adequate at least for slow VM
40665      instructions. */
40666   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40667 #endif
40668 #if defined (JITTER_PROFILE_COUNT)
40669   /* Notice that, differently from the code above, this
40670      instrumentation code *can* be reordered freely: as long as a
40671      VM instruction is counted, the count increment can be placed
40672      anyehere.  Let GCC move this code and possibly achieve better
40673      throughput by exploiting instruction-level parallelism and
40674      therefore approximate more closely a non-profiled build. */
40675   JITTER_PROFILE_COUNT_UPDATE
40676      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40677       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40678 #endif
40679 
40680 /* User-specified code, instruction-beginning-c part: beginning. */
40681 
40682 /* User-specified code, instruction-beginning-c part: end */
40683 
40684 
40685     /* User code for sel . */
40686 #line 5780 "../../libpoke/pvm.jitter"
40687 
40688     JITTER_PUSH_STACK (pvm_elemsof (JITTER_TOP_STACK ()));
40689 
40690     /* End of the user code for sel . */
40691 
40692 /* User-specified code, instruction-end-c part: beginning. */
40693 
40694 /* User-specified code, instruction-end-c part: end */
40695 
40696     /* Undefine the sel argument macros so they can't be used
40697        by mistake in the instruction body coming next. */
40698 
40699 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40700 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40701 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40702 
40703   }
40704  JITTER_INSTRUCTION_EPILOG_(sel, sel, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40705 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40706 
40707   JITTER_INSTRUCTION_PROLOG_(setr/%rR, setr___rrR, cold)
40708   {
40709     /* This specialized instruction is not a replacement. */
40710 #   undef JITTER_BRANCH_FAST
40711 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40712 #   undef JITTER_BRANCH_FAST_IF_ZERO
40713 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40714 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40715 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40716 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40717 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40718 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40719 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40720 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40721 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40722 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40723 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
40724 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40725 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
40726 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40727 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
40728 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40729 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
40730 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40731 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40732 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40733 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40734 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40735 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40736 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40737 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40738 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40739 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40740 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40741 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40742 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40743 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40744 #   undef JITTER_BRANCH_FAST_IF_AND
40745 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
40746 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40747 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
40748 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40749 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40750 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40751 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40752 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40753 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40754 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40755 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40756 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40757 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40758 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40759 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40760 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40761 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40762 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40763 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40764 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40765 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40766 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40767 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40768 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40769 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40770 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40771 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40772 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40773 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40774 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       281
40775 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         setr/%rR
40776 
40777 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME setr___rrR
40778 
40779   /* The residual arity for this instruction does not depend on fast labels. */
40780   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
40781 
40782     /* The 0th argument is a slow (therefore residual, passed as an offset)
40783         register. */
40784   /* Define a macro expanding to the slow register offset. */
40785 #if defined(JITTER_DISPATCH_NO_THREADING)
40786 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
40787 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
40788 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
40789 #else
40790 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
40791 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40792   /* Define a macro expanding to an l-value for the VM register content. */
40793 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
40794 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40795 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40796 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40797 #   define JITTER_ARGF0 JITTER_ARGP0
40798 
40799 
40800 #if defined (JITTER_PROFILE_SAMPLE)
40801   JITTER_PROFILE_SAMPLE_UPDATE
40802      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40803       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40804   /* Force the compiler not move sample-profiling instrumentation
40805      beyond this point; this way the actual user code is timed.
40806      This is still not perfect, as residuals are materialised before
40807      we arrive here, but should be adequate at least for slow VM
40808      instructions. */
40809   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40810 #endif
40811 #if defined (JITTER_PROFILE_COUNT)
40812   /* Notice that, differently from the code above, this
40813      instrumentation code *can* be reordered freely: as long as a
40814      VM instruction is counted, the count increment can be placed
40815      anyehere.  Let GCC move this code and possibly achieve better
40816      throughput by exploiting instruction-level parallelism and
40817      therefore approximate more closely a non-profiled build. */
40818   JITTER_PROFILE_COUNT_UPDATE
40819      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40820       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40821 #endif
40822 
40823 /* User-specified code, instruction-beginning-c part: beginning. */
40824 
40825 /* User-specified code, instruction-beginning-c part: end */
40826 
40827 
40828     /* User code for setr/%rR . */
40829 #line 2205 "../../libpoke/pvm.jitter"
40830 
40831     JITTER_ARG0 = JITTER_TOP_STACK();
40832 
40833     /* End of the user code for setr/%rR . */
40834 
40835 /* User-specified code, instruction-end-c part: beginning. */
40836 
40837 /* User-specified code, instruction-end-c part: end */
40838 
40839     /* Undefine the setr/%rR argument macros so they can't be used
40840        by mistake in the instruction body coming next. */
40841 #   undef JITTER_SLOW_REGISTER_OFFSET0
40842 #   undef JITTER_ARG0
40843 #   undef JITTER_ARGN0
40844 #   undef JITTER_ARGU0
40845 #   undef JITTER_ARGP0
40846 #   undef JITTER_ARGF0
40847 
40848 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40849 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40850 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40851 
40852   }
40853  JITTER_INSTRUCTION_EPILOG_(setr/%rR, setr___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40854 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40855 
40856   JITTER_INSTRUCTION_PROLOG_(siz, siz, hot)
40857   {
40858     /* This specialized instruction is not a replacement. */
40859 #   undef JITTER_BRANCH_FAST
40860 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40861 #   undef JITTER_BRANCH_FAST_IF_ZERO
40862 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40863 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40864 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40865 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40866 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40867 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40868 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40869 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40870 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40871 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40872 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
40873 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40874 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
40875 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40876 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
40877 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40878 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
40879 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40880 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40881 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40882 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40883 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40884 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40885 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40886 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40887 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40888 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40889 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40890 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40891 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40892 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40893 #   undef JITTER_BRANCH_FAST_IF_AND
40894 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
40895 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40896 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
40897 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40898 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40899 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40900 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40901 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40902 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40903 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40904 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40905 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40906 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40907 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40908 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40909 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40910 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40911 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40912 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40913 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40914 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40915 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40916 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40917 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40918 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40919 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40920 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40921 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40922 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40923 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       282
40924 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         siz
40925 
40926 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME siz
40927 
40928   /* The residual arity for this instruction does not depend on fast labels. */
40929   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
40930 
40931 
40932 #if defined (JITTER_PROFILE_SAMPLE)
40933   JITTER_PROFILE_SAMPLE_UPDATE
40934      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40935       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40936   /* Force the compiler not move sample-profiling instrumentation
40937      beyond this point; this way the actual user code is timed.
40938      This is still not perfect, as residuals are materialised before
40939      we arrive here, but should be adequate at least for slow VM
40940      instructions. */
40941   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40942 #endif
40943 #if defined (JITTER_PROFILE_COUNT)
40944   /* Notice that, differently from the code above, this
40945      instrumentation code *can* be reordered freely: as long as a
40946      VM instruction is counted, the count increment can be placed
40947      anyehere.  Let GCC move this code and possibly achieve better
40948      throughput by exploiting instruction-level parallelism and
40949      therefore approximate more closely a non-profiled build. */
40950   JITTER_PROFILE_COUNT_UPDATE
40951      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40952       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40953 #endif
40954 
40955 /* User-specified code, instruction-beginning-c part: beginning. */
40956 
40957 /* User-specified code, instruction-beginning-c part: end */
40958 
40959 
40960     /* User code for siz . */
40961 #line 5762 "../../libpoke/pvm.jitter"
40962 
40963     uint64_t size = pvm_sizeof (JITTER_TOP_STACK ());
40964     JITTER_PUSH_STACK (PVM_MAKE_ULONG (size, 64));
40965 
40966     /* End of the user code for siz . */
40967 
40968 /* User-specified code, instruction-end-c part: beginning. */
40969 
40970 /* User-specified code, instruction-end-c part: end */
40971 
40972     /* Undefine the siz argument macros so they can't be used
40973        by mistake in the instruction body coming next. */
40974 
40975 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40976 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40977 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40978 
40979   }
40980  JITTER_INSTRUCTION_EPILOG_(siz, siz, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40981 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40982 
40983   JITTER_INSTRUCTION_PROLOG_(smodi, smodi, hot)
40984   {
40985     /* This specialized instruction is not a replacement. */
40986 #   undef JITTER_BRANCH_FAST
40987 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
40988 #   undef JITTER_BRANCH_FAST_IF_ZERO
40989 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
40990 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40991 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
40992 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40993 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
40994 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40995 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
40996 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40997 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
40998 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40999 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41000 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41001 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41002 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41003 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41004 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41005 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41006 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41007 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41008 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41009 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41010 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41011 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41012 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41013 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41014 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41015 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41016 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41017 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41018 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41019 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41020 #   undef JITTER_BRANCH_FAST_IF_AND
41021 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41022 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41023 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41024 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41025 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41026 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41027 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41028 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41029 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41030 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41031 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41032 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41033 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41034 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41035 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41036 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41037 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41038 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41039 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41040 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41041 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41042 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41043 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41044 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41045 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41046 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41047 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41048 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41049 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41050 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       283
41051 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         smodi
41052 
41053 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME smodi
41054 
41055   /* The residual arity for this instruction does not depend on fast labels. */
41056   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41057 
41058 
41059 #if defined (JITTER_PROFILE_SAMPLE)
41060   JITTER_PROFILE_SAMPLE_UPDATE
41061      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41062       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41063   /* Force the compiler not move sample-profiling instrumentation
41064      beyond this point; this way the actual user code is timed.
41065      This is still not perfect, as residuals are materialised before
41066      we arrive here, but should be adequate at least for slow VM
41067      instructions. */
41068   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41069 #endif
41070 #if defined (JITTER_PROFILE_COUNT)
41071   /* Notice that, differently from the code above, this
41072      instrumentation code *can* be reordered freely: as long as a
41073      VM instruction is counted, the count increment can be placed
41074      anyehere.  Let GCC move this code and possibly achieve better
41075      throughput by exploiting instruction-level parallelism and
41076      therefore approximate more closely a non-profiled build. */
41077   JITTER_PROFILE_COUNT_UPDATE
41078      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41079       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41080 #endif
41081 
41082 /* User-specified code, instruction-beginning-c part: beginning. */
41083 
41084 /* User-specified code, instruction-beginning-c part: end */
41085 
41086 
41087     /* User code for smodi . */
41088 #line 4570 "../../libpoke/pvm.jitter"
41089 
41090     pvm_val sct = JITTER_UNDER_TOP_STACK ();
41091     pvm_val index = JITTER_TOP_STACK ();
41092 
41093     if (PVM_VAL_ULONG (index) < 0
41094         || (PVM_VAL_ULONG (index) >=
41095             PVM_VAL_INTEGRAL (PVM_VAL_SCT_NFIELDS (sct))))
41096       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
41097 
41098     JITTER_PUSH_STACK (PVM_VAL_SCT_FIELD_MODIFIED (sct,
41099                                                    PVM_VAL_ULONG (index)));
41100 
41101     /* End of the user code for smodi . */
41102 
41103 /* User-specified code, instruction-end-c part: beginning. */
41104 
41105 /* User-specified code, instruction-end-c part: end */
41106 
41107     /* Undefine the smodi argument macros so they can't be used
41108        by mistake in the instruction body coming next. */
41109 
41110 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41111 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41112 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41113 
41114   }
41115  JITTER_INSTRUCTION_EPILOG_(smodi, smodi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41116 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41117 
41118   JITTER_INSTRUCTION_PROLOG_(sref, sref, hot)
41119   {
41120     /* This specialized instruction is not a replacement. */
41121 #   undef JITTER_BRANCH_FAST
41122 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
41123 #   undef JITTER_BRANCH_FAST_IF_ZERO
41124 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
41125 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41126 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
41127 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41128 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
41129 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41130 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
41131 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41132 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
41133 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41134 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41135 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41136 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41137 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41138 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41139 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41140 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41141 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41142 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41143 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41144 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41145 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41146 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41147 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41148 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41149 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41150 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41151 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41152 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41153 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41154 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41155 #   undef JITTER_BRANCH_FAST_IF_AND
41156 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41157 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41158 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41159 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41160 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41161 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41162 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41163 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41164 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41165 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41166 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41167 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41168 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41169 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41170 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41171 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41172 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41173 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41174 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41175 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41176 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41177 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41178 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41179 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41180 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41181 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41182 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41183 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41184 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41185 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       284
41186 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         sref
41187 
41188 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME sref
41189 
41190   /* The residual arity for this instruction does not depend on fast labels. */
41191   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41192 
41193 
41194 #if defined (JITTER_PROFILE_SAMPLE)
41195   JITTER_PROFILE_SAMPLE_UPDATE
41196      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41197       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41198   /* Force the compiler not move sample-profiling instrumentation
41199      beyond this point; this way the actual user code is timed.
41200      This is still not perfect, as residuals are materialised before
41201      we arrive here, but should be adequate at least for slow VM
41202      instructions. */
41203   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41204 #endif
41205 #if defined (JITTER_PROFILE_COUNT)
41206   /* Notice that, differently from the code above, this
41207      instrumentation code *can* be reordered freely: as long as a
41208      VM instruction is counted, the count increment can be placed
41209      anyehere.  Let GCC move this code and possibly achieve better
41210      throughput by exploiting instruction-level parallelism and
41211      therefore approximate more closely a non-profiled build. */
41212   JITTER_PROFILE_COUNT_UPDATE
41213      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41214       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41215 #endif
41216 
41217 /* User-specified code, instruction-beginning-c part: beginning. */
41218 
41219 /* User-specified code, instruction-beginning-c part: end */
41220 
41221 
41222     /* User code for sref . */
41223 #line 4417 "../../libpoke/pvm.jitter"
41224 
41225     pvm_val val = pvm_ref_struct (JITTER_UNDER_TOP_STACK (),
41226                                   JITTER_TOP_STACK ());
41227 
41228     if (val == PVM_NULL)
41229       PVM_RAISE_DFL (PVM_E_ELEM);
41230     JITTER_PUSH_STACK (val);
41231 
41232     /* End of the user code for sref . */
41233 
41234 /* User-specified code, instruction-end-c part: beginning. */
41235 
41236 /* User-specified code, instruction-end-c part: end */
41237 
41238     /* Undefine the sref argument macros so they can't be used
41239        by mistake in the instruction body coming next. */
41240 
41241 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41242 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41243 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41244 
41245   }
41246  JITTER_INSTRUCTION_EPILOG_(sref, sref, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41247 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41248 
41249   JITTER_INSTRUCTION_PROLOG_(srefi, srefi, hot)
41250   {
41251     /* This specialized instruction is not a replacement. */
41252 #   undef JITTER_BRANCH_FAST
41253 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
41254 #   undef JITTER_BRANCH_FAST_IF_ZERO
41255 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
41256 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41257 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
41258 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41259 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
41260 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41261 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
41262 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41263 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
41264 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41265 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41266 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41267 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41268 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41269 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41270 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41271 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41272 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41273 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41274 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41275 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41276 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41277 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41278 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41279 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41280 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41281 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41282 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41283 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41284 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41285 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41286 #   undef JITTER_BRANCH_FAST_IF_AND
41287 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41288 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41289 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41290 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41291 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41292 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41293 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41294 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41295 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41296 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41297 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41298 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41299 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41300 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41301 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41302 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41303 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41304 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41305 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41306 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41307 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41308 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41309 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41310 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41311 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41312 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41313 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41314 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41315 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41316 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       285
41317 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         srefi
41318 
41319 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME srefi
41320 
41321   /* The residual arity for this instruction does not depend on fast labels. */
41322   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41323 
41324 
41325 #if defined (JITTER_PROFILE_SAMPLE)
41326   JITTER_PROFILE_SAMPLE_UPDATE
41327      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41328       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41329   /* Force the compiler not move sample-profiling instrumentation
41330      beyond this point; this way the actual user code is timed.
41331      This is still not perfect, as residuals are materialised before
41332      we arrive here, but should be adequate at least for slow VM
41333      instructions. */
41334   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41335 #endif
41336 #if defined (JITTER_PROFILE_COUNT)
41337   /* Notice that, differently from the code above, this
41338      instrumentation code *can* be reordered freely: as long as a
41339      VM instruction is counted, the count increment can be placed
41340      anyehere.  Let GCC move this code and possibly achieve better
41341      throughput by exploiting instruction-level parallelism and
41342      therefore approximate more closely a non-profiled build. */
41343   JITTER_PROFILE_COUNT_UPDATE
41344      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41345       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41346 #endif
41347 
41348 /* User-specified code, instruction-beginning-c part: beginning. */
41349 
41350 /* User-specified code, instruction-beginning-c part: end */
41351 
41352 
41353     /* User code for srefi . */
41354 #line 4495 "../../libpoke/pvm.jitter"
41355 
41356     pvm_val sct = JITTER_UNDER_TOP_STACK ();
41357     pvm_val index = JITTER_TOP_STACK ();
41358 
41359     if (PVM_VAL_ULONG (index) < 0
41360         || (PVM_VAL_ULONG (index) >=
41361             PVM_VAL_INTEGRAL (PVM_VAL_SCT_NFIELDS (sct))))
41362       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
41363 
41364     JITTER_PUSH_STACK (PVM_VAL_SCT_FIELD_VALUE (sct,
41365                                                PVM_VAL_ULONG (index)));
41366 
41367     /* End of the user code for srefi . */
41368 
41369 /* User-specified code, instruction-end-c part: beginning. */
41370 
41371 /* User-specified code, instruction-end-c part: end */
41372 
41373     /* Undefine the srefi argument macros so they can't be used
41374        by mistake in the instruction body coming next. */
41375 
41376 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41377 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41378 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41379 
41380   }
41381  JITTER_INSTRUCTION_EPILOG_(srefi, srefi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41382 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41383 
41384   JITTER_INSTRUCTION_PROLOG_(srefia, srefia, hot)
41385   {
41386     /* This specialized instruction is not a replacement. */
41387 #   undef JITTER_BRANCH_FAST
41388 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
41389 #   undef JITTER_BRANCH_FAST_IF_ZERO
41390 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
41391 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41392 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
41393 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41394 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
41395 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41396 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
41397 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41398 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
41399 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41400 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41401 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41402 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41403 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41404 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41405 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41406 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41407 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41408 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41409 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41410 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41411 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41412 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41413 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41414 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41415 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41416 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41417 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41418 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41419 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41420 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41421 #   undef JITTER_BRANCH_FAST_IF_AND
41422 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41423 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41424 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41425 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41426 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41427 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41428 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41429 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41430 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41431 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41432 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41433 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41434 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41435 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41436 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41437 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41438 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41439 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41440 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41441 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41442 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41443 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41444 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41445 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41446 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41447 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41448 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41449 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41450 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41451 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       286
41452 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         srefia
41453 
41454 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME srefia
41455 
41456   /* The residual arity for this instruction does not depend on fast labels. */
41457   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41458 
41459 
41460 #if defined (JITTER_PROFILE_SAMPLE)
41461   JITTER_PROFILE_SAMPLE_UPDATE
41462      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41463       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41464   /* Force the compiler not move sample-profiling instrumentation
41465      beyond this point; this way the actual user code is timed.
41466      This is still not perfect, as residuals are materialised before
41467      we arrive here, but should be adequate at least for slow VM
41468      instructions. */
41469   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41470 #endif
41471 #if defined (JITTER_PROFILE_COUNT)
41472   /* Notice that, differently from the code above, this
41473      instrumentation code *can* be reordered freely: as long as a
41474      VM instruction is counted, the count increment can be placed
41475      anyehere.  Let GCC move this code and possibly achieve better
41476      throughput by exploiting instruction-level parallelism and
41477      therefore approximate more closely a non-profiled build. */
41478   JITTER_PROFILE_COUNT_UPDATE
41479      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41480       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41481 #endif
41482 
41483 /* User-specified code, instruction-beginning-c part: beginning. */
41484 
41485 /* User-specified code, instruction-beginning-c part: end */
41486 
41487 
41488     /* User code for srefia . */
41489 #line 4520 "../../libpoke/pvm.jitter"
41490 
41491     pvm_val sct = JITTER_UNDER_TOP_STACK ();
41492     pvm_val index = JITTER_TOP_STACK ();
41493     int absent_p;
41494 
41495     if (PVM_VAL_ULONG (index) < 0
41496         || (PVM_VAL_ULONG (index) >=
41497             PVM_VAL_INTEGRAL (PVM_VAL_SCT_NFIELDS (sct))))
41498       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
41499 
41500     absent_p = PVM_VAL_SCT_FIELD_ABSENT_P (sct, PVM_VAL_ULONG (index));
41501     JITTER_PUSH_STACK (PVM_MAKE_INT (absent_p, 32));
41502 
41503     /* End of the user code for srefia . */
41504 
41505 /* User-specified code, instruction-end-c part: beginning. */
41506 
41507 /* User-specified code, instruction-end-c part: end */
41508 
41509     /* Undefine the srefia argument macros so they can't be used
41510        by mistake in the instruction body coming next. */
41511 
41512 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41513 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41514 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41515 
41516   }
41517  JITTER_INSTRUCTION_EPILOG_(srefia, srefia, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41518 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41519 
41520   JITTER_INSTRUCTION_PROLOG_(srefio, srefio, hot)
41521   {
41522     /* This specialized instruction is not a replacement. */
41523 #   undef JITTER_BRANCH_FAST
41524 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
41525 #   undef JITTER_BRANCH_FAST_IF_ZERO
41526 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
41527 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41528 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
41529 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41530 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
41531 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41532 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
41533 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41534 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
41535 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41536 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41537 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41538 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41539 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41540 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41541 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41542 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41543 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41544 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41545 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41546 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41547 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41548 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41549 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41550 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41551 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41552 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41553 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41554 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41555 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41556 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41557 #   undef JITTER_BRANCH_FAST_IF_AND
41558 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41559 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41560 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41561 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41562 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41563 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41564 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41565 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41566 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41567 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41568 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41569 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41570 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41571 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41572 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41573 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41574 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41575 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41576 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41577 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41578 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41579 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41580 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41581 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41582 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41583 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41584 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41585 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41586 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41587 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       287
41588 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         srefio
41589 
41590 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME srefio
41591 
41592   /* The residual arity for this instruction does not depend on fast labels. */
41593   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41594 
41595 
41596 #if defined (JITTER_PROFILE_SAMPLE)
41597   JITTER_PROFILE_SAMPLE_UPDATE
41598      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41599       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41600   /* Force the compiler not move sample-profiling instrumentation
41601      beyond this point; this way the actual user code is timed.
41602      This is still not perfect, as residuals are materialised before
41603      we arrive here, but should be adequate at least for slow VM
41604      instructions. */
41605   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41606 #endif
41607 #if defined (JITTER_PROFILE_COUNT)
41608   /* Notice that, differently from the code above, this
41609      instrumentation code *can* be reordered freely: as long as a
41610      VM instruction is counted, the count increment can be placed
41611      anyehere.  Let GCC move this code and possibly achieve better
41612      throughput by exploiting instruction-level parallelism and
41613      therefore approximate more closely a non-profiled build. */
41614   JITTER_PROFILE_COUNT_UPDATE
41615      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41616       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41617 #endif
41618 
41619 /* User-specified code, instruction-beginning-c part: beginning. */
41620 
41621 /* User-specified code, instruction-beginning-c part: end */
41622 
41623 
41624     /* User code for srefio . */
41625 #line 4545 "../../libpoke/pvm.jitter"
41626 
41627     pvm_val sct = JITTER_UNDER_TOP_STACK ();
41628     pvm_val index = JITTER_TOP_STACK ();
41629 
41630     if (PVM_VAL_ULONG (index) < 0
41631         || (PVM_VAL_ULONG (index) >=
41632             PVM_VAL_INTEGRAL (PVM_VAL_SCT_NFIELDS (sct))))
41633       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
41634 
41635     JITTER_PUSH_STACK (PVM_VAL_SCT_FIELD_OFFSET (sct,
41636                                                  PVM_VAL_ULONG (index)));
41637 
41638     /* End of the user code for srefio . */
41639 
41640 /* User-specified code, instruction-end-c part: beginning. */
41641 
41642 /* User-specified code, instruction-end-c part: end */
41643 
41644     /* Undefine the srefio argument macros so they can't be used
41645        by mistake in the instruction body coming next. */
41646 
41647 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41648 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41649 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41650 
41651   }
41652  JITTER_INSTRUCTION_EPILOG_(srefio, srefio, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41653 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41654 
41655   JITTER_INSTRUCTION_PROLOG_(srefmnt, srefmnt, hot)
41656   {
41657     /* This specialized instruction is not a replacement. */
41658 #   undef JITTER_BRANCH_FAST
41659 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
41660 #   undef JITTER_BRANCH_FAST_IF_ZERO
41661 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
41662 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41663 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
41664 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41665 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
41666 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41667 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
41668 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41669 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
41670 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41671 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41672 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41673 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41674 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41675 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41676 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41677 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41678 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41679 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41680 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41681 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41682 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41683 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41684 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41685 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41686 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41687 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41688 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41689 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41690 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41691 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41692 #   undef JITTER_BRANCH_FAST_IF_AND
41693 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41694 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41695 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41696 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41697 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41698 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41699 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41700 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41701 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41702 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41703 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41704 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41705 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41706 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41707 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41708 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41709 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41710 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41711 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41712 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41713 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41714 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41715 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41716 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41717 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41718 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41719 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41720 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41721 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41722 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       288
41723 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         srefmnt
41724 
41725 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME srefmnt
41726 
41727   /* The residual arity for this instruction does not depend on fast labels. */
41728   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41729 
41730 
41731 #if defined (JITTER_PROFILE_SAMPLE)
41732   JITTER_PROFILE_SAMPLE_UPDATE
41733      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41734       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41735   /* Force the compiler not move sample-profiling instrumentation
41736      beyond this point; this way the actual user code is timed.
41737      This is still not perfect, as residuals are materialised before
41738      we arrive here, but should be adequate at least for slow VM
41739      instructions. */
41740   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41741 #endif
41742 #if defined (JITTER_PROFILE_COUNT)
41743   /* Notice that, differently from the code above, this
41744      instrumentation code *can* be reordered freely: as long as a
41745      VM instruction is counted, the count increment can be placed
41746      anyehere.  Let GCC move this code and possibly achieve better
41747      throughput by exploiting instruction-level parallelism and
41748      therefore approximate more closely a non-profiled build. */
41749   JITTER_PROFILE_COUNT_UPDATE
41750      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41751       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41752 #endif
41753 
41754 /* User-specified code, instruction-beginning-c part: beginning. */
41755 
41756 /* User-specified code, instruction-beginning-c part: end */
41757 
41758 
41759     /* User code for srefmnt . */
41760 #line 4458 "../../libpoke/pvm.jitter"
41761 
41762     pvm_val sct = JITTER_UNDER_TOP_STACK ();
41763     pvm_val name = JITTER_TOP_STACK ();
41764     pvm_val cls = pvm_get_struct_method (sct, PVM_VAL_STR (name));
41765 
41766     JITTER_PUSH_STACK (cls);
41767 
41768     /* End of the user code for srefmnt . */
41769 
41770 /* User-specified code, instruction-end-c part: beginning. */
41771 
41772 /* User-specified code, instruction-end-c part: end */
41773 
41774     /* Undefine the srefmnt argument macros so they can't be used
41775        by mistake in the instruction body coming next. */
41776 
41777 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41778 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41779 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41780 
41781   }
41782  JITTER_INSTRUCTION_EPILOG_(srefmnt, srefmnt, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41783 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41784 
41785   JITTER_INSTRUCTION_PROLOG_(srefnt, srefnt, hot)
41786   {
41787     /* This specialized instruction is not a replacement. */
41788 #   undef JITTER_BRANCH_FAST
41789 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
41790 #   undef JITTER_BRANCH_FAST_IF_ZERO
41791 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
41792 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41793 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
41794 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41795 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
41796 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41797 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
41798 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41799 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
41800 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41801 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41802 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41803 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41804 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41805 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41806 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41807 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41808 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41809 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41810 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41811 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41812 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41813 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41814 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41815 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41816 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41817 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41818 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41819 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41820 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41821 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41822 #   undef JITTER_BRANCH_FAST_IF_AND
41823 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41824 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41825 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41826 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41827 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41828 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41829 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41830 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41831 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41832 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41833 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41834 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41835 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41836 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41837 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41838 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41839 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41840 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41841 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41842 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41843 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41844 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41845 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41846 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41847 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41848 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41849 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41850 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41851 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41852 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       289
41853 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         srefnt
41854 
41855 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME srefnt
41856 
41857   /* The residual arity for this instruction does not depend on fast labels. */
41858   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41859 
41860 
41861 #if defined (JITTER_PROFILE_SAMPLE)
41862   JITTER_PROFILE_SAMPLE_UPDATE
41863      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41864       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41865   /* Force the compiler not move sample-profiling instrumentation
41866      beyond this point; this way the actual user code is timed.
41867      This is still not perfect, as residuals are materialised before
41868      we arrive here, but should be adequate at least for slow VM
41869      instructions. */
41870   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41871 #endif
41872 #if defined (JITTER_PROFILE_COUNT)
41873   /* Notice that, differently from the code above, this
41874      instrumentation code *can* be reordered freely: as long as a
41875      VM instruction is counted, the count increment can be placed
41876      anyehere.  Let GCC move this code and possibly achieve better
41877      throughput by exploiting instruction-level parallelism and
41878      therefore approximate more closely a non-profiled build. */
41879   JITTER_PROFILE_COUNT_UPDATE
41880      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41881       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41882 #endif
41883 
41884 /* User-specified code, instruction-beginning-c part: beginning. */
41885 
41886 /* User-specified code, instruction-beginning-c part: end */
41887 
41888 
41889     /* User code for srefnt . */
41890 #line 4477 "../../libpoke/pvm.jitter"
41891 
41892     pvm_val val = pvm_ref_struct (JITTER_UNDER_TOP_STACK (),
41893                                   JITTER_TOP_STACK ());
41894 
41895     JITTER_PUSH_STACK (val);
41896 
41897     /* End of the user code for srefnt . */
41898 
41899 /* User-specified code, instruction-end-c part: beginning. */
41900 
41901 /* User-specified code, instruction-end-c part: end */
41902 
41903     /* Undefine the srefnt argument macros so they can't be used
41904        by mistake in the instruction body coming next. */
41905 
41906 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41907 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41908 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41909 
41910   }
41911  JITTER_INSTRUCTION_EPILOG_(srefnt, srefnt, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41912 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41913 
41914   JITTER_INSTRUCTION_PROLOG_(srefo, srefo, hot)
41915   {
41916     /* This specialized instruction is not a replacement. */
41917 #   undef JITTER_BRANCH_FAST
41918 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
41919 #   undef JITTER_BRANCH_FAST_IF_ZERO
41920 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
41921 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41922 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
41923 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41924 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
41925 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41926 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
41927 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41928 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
41929 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41930 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
41931 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41932 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
41933 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41934 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
41935 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41936 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
41937 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41938 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41939 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41940 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41941 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41942 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41943 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41944 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41945 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41946 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41947 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41948 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41949 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41950 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41951 #   undef JITTER_BRANCH_FAST_IF_AND
41952 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
41953 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41954 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
41955 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41956 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41957 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41958 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41959 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41960 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41961 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41962 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41963 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41964 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41965 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41966 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41967 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41968 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41969 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41970 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41971 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41972 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41973 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41974 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41975 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41976 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41977 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41978 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41979 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41980 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41981 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       290
41982 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         srefo
41983 
41984 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME srefo
41985 
41986   /* The residual arity for this instruction does not depend on fast labels. */
41987   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
41988 
41989 
41990 #if defined (JITTER_PROFILE_SAMPLE)
41991   JITTER_PROFILE_SAMPLE_UPDATE
41992      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41993       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41994   /* Force the compiler not move sample-profiling instrumentation
41995      beyond this point; this way the actual user code is timed.
41996      This is still not perfect, as residuals are materialised before
41997      we arrive here, but should be adequate at least for slow VM
41998      instructions. */
41999   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42000 #endif
42001 #if defined (JITTER_PROFILE_COUNT)
42002   /* Notice that, differently from the code above, this
42003      instrumentation code *can* be reordered freely: as long as a
42004      VM instruction is counted, the count increment can be placed
42005      anyehere.  Let GCC move this code and possibly achieve better
42006      throughput by exploiting instruction-level parallelism and
42007      therefore approximate more closely a non-profiled build. */
42008   JITTER_PROFILE_COUNT_UPDATE
42009      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42010       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42011 #endif
42012 
42013 /* User-specified code, instruction-beginning-c part: beginning. */
42014 
42015 /* User-specified code, instruction-beginning-c part: end */
42016 
42017 
42018     /* User code for srefo . */
42019 #line 4438 "../../libpoke/pvm.jitter"
42020 
42021     pvm_val sct = JITTER_UNDER_TOP_STACK ();
42022     pvm_val fname = JITTER_TOP_STACK ();
42023     pvm_val boff = pvm_refo_struct (sct, fname);
42024 
42025     if (boff == PVM_NULL)
42026       PVM_RAISE_DFL (PVM_E_ELEM);
42027     JITTER_PUSH_STACK (boff);
42028 
42029     /* End of the user code for srefo . */
42030 
42031 /* User-specified code, instruction-end-c part: beginning. */
42032 
42033 /* User-specified code, instruction-end-c part: end */
42034 
42035     /* Undefine the srefo argument macros so they can't be used
42036        by mistake in the instruction body coming next. */
42037 
42038 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42039 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42040 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42041 
42042   }
42043  JITTER_INSTRUCTION_EPILOG_(srefo, srefo, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42044 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42045 
42046   JITTER_INSTRUCTION_PROLOG_(sset, sset, hot)
42047   {
42048     /* This specialized instruction is not a replacement. */
42049 #   undef JITTER_BRANCH_FAST
42050 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42051 #   undef JITTER_BRANCH_FAST_IF_ZERO
42052 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42053 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42054 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42055 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42056 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
42057 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42058 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
42059 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42060 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
42061 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42062 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
42063 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42064 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
42065 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42066 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
42067 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42068 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
42069 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42070 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42071 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42072 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42073 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42074 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42075 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42076 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42077 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42078 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42079 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42080 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42081 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42082 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42083 #   undef JITTER_BRANCH_FAST_IF_AND
42084 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
42085 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42086 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
42087 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42088 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42089 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42090 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42091 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42092 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42093 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42094 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42095 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42096 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42097 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42098 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42099 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42100 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42101 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42102 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42103 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42104 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42105 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42106 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42107 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42108 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42109 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42110 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42111 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42112 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42113 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       291
42114 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         sset
42115 
42116 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME sset
42117 
42118   /* The residual arity for this instruction does not depend on fast labels. */
42119   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
42120 
42121 
42122 #if defined (JITTER_PROFILE_SAMPLE)
42123   JITTER_PROFILE_SAMPLE_UPDATE
42124      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42125       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42126   /* Force the compiler not move sample-profiling instrumentation
42127      beyond this point; this way the actual user code is timed.
42128      This is still not perfect, as residuals are materialised before
42129      we arrive here, but should be adequate at least for slow VM
42130      instructions. */
42131   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42132 #endif
42133 #if defined (JITTER_PROFILE_COUNT)
42134   /* Notice that, differently from the code above, this
42135      instrumentation code *can* be reordered freely: as long as a
42136      VM instruction is counted, the count increment can be placed
42137      anyehere.  Let GCC move this code and possibly achieve better
42138      throughput by exploiting instruction-level parallelism and
42139      therefore approximate more closely a non-profiled build. */
42140   JITTER_PROFILE_COUNT_UPDATE
42141      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42142       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42143 #endif
42144 
42145 /* User-specified code, instruction-beginning-c part: beginning. */
42146 
42147 /* User-specified code, instruction-beginning-c part: end */
42148 
42149 
42150     /* User code for sset . */
42151 #line 4392 "../../libpoke/pvm.jitter"
42152 
42153     pvm_val val = JITTER_TOP_STACK ();
42154     pvm_val name = JITTER_UNDER_TOP_STACK ();
42155     pvm_val sct;
42156 
42157     JITTER_DROP_STACK ();
42158     JITTER_DROP_STACK ();
42159 
42160     sct = JITTER_TOP_STACK ();
42161     if (!pvm_set_struct (sct, name, val))
42162        PVM_RAISE_DFL (PVM_E_ELEM);
42163 
42164     /* End of the user code for sset . */
42165 
42166 /* User-specified code, instruction-end-c part: beginning. */
42167 
42168 /* User-specified code, instruction-end-c part: end */
42169 
42170     /* Undefine the sset argument macros so they can't be used
42171        by mistake in the instruction body coming next. */
42172 
42173 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42174 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42175 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42176 
42177   }
42178  JITTER_INSTRUCTION_EPILOG_(sset, sset, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42179 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42180 
42181   JITTER_INSTRUCTION_PROLOG_(strace/nR, strace__nR, cold)
42182   {
42183     /* This specialized instruction is not a replacement. */
42184 #   undef JITTER_BRANCH_FAST
42185 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42186 #   undef JITTER_BRANCH_FAST_IF_ZERO
42187 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42188 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42189 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42190 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42191 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
42192 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42193 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
42194 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42195 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
42196 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42197 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
42198 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42199 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
42200 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42201 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
42202 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42203 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
42204 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42205 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42206 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42207 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42208 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42209 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42210 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42211 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42212 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42213 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42214 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42215 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42216 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42217 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42218 #   undef JITTER_BRANCH_FAST_IF_AND
42219 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
42220 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42221 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
42222 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42223 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42224 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42225 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42226 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42227 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42228 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42229 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42230 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42231 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42232 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42233 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42234 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42235 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42236 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42237 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42238 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42239 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42240 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42241 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42242 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42243 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42244 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42245 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42246 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42247 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42248 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       292
42249 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         strace/nR
42250 
42251 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME strace__nR
42252 
42253   /* The residual arity for this instruction does not depend on fast labels. */
42254   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
42255 
42256     /* The 0th argument is a residual literal. */
42257 #if defined(JITTER_DISPATCH_NO_THREADING)
42258 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
42259     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42260 #elif defined (JITTER_REPLICATE)
42261 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
42262 #else
42263 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
42264 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42265 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42266 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42267 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42268 #   define JITTER_ARGF0 JITTER_ARGP0
42269 
42270 
42271 #if defined (JITTER_PROFILE_SAMPLE)
42272   JITTER_PROFILE_SAMPLE_UPDATE
42273      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42274       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42275   /* Force the compiler not move sample-profiling instrumentation
42276      beyond this point; this way the actual user code is timed.
42277      This is still not perfect, as residuals are materialised before
42278      we arrive here, but should be adequate at least for slow VM
42279      instructions. */
42280   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42281 #endif
42282 #if defined (JITTER_PROFILE_COUNT)
42283   /* Notice that, differently from the code above, this
42284      instrumentation code *can* be reordered freely: as long as a
42285      VM instruction is counted, the count increment can be placed
42286      anyehere.  Let GCC move this code and possibly achieve better
42287      throughput by exploiting instruction-level parallelism and
42288      therefore approximate more closely a non-profiled build. */
42289   JITTER_PROFILE_COUNT_UPDATE
42290      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42291       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42292 #endif
42293 
42294 /* User-specified code, instruction-beginning-c part: beginning. */
42295 
42296 /* User-specified code, instruction-beginning-c part: end */
42297 
42298 
42299     /* User code for strace/nR . */
42300 #line 5615 "../../libpoke/pvm.jitter"
42301 
42302      pvm_val tmp[1024];
42303      int i = 0, j;
42304      int num_elems = (int) JITTER_ARGN0;
42305 
42306      while (((num_elems == 0 || i < num_elems)
42307              && (JITTER_HEIGHT_STACK () !=
42308                  JITTER_STATE_BACKING_FIELD (canary))))
42309         {
42310           assert (i < 1024);
42311           pvm_print_val_with_params (JITTER_STATE_BACKING_FIELD (vm),
42312                                      JITTER_TOP_STACK (),
42313                                      0 /* depth */,
42314                                      PVM_PRINT_FLAT,
42315                                      16 /* base */,
42316                                      2 /* indent */,
42317                                      0 /* acutoff */,
42318                                      PVM_PRINT_F_MAPS);
42319           pk_puts ("\n");
42320           tmp[i++] = JITTER_TOP_STACK ();
42321           JITTER_DROP_STACK ();
42322         }
42323 
42324      /* Restore the stack.  */
42325      for (j = (i - 1); j >= 0; j--)
42326         JITTER_PUSH_STACK (tmp[j]);
42327 
42328     /* End of the user code for strace/nR . */
42329 
42330 /* User-specified code, instruction-end-c part: beginning. */
42331 
42332 /* User-specified code, instruction-end-c part: end */
42333 
42334     /* Undefine the strace/nR argument macros so they can't be used
42335        by mistake in the instruction body coming next. */
42336 #   undef JITTER_SLOW_REGISTER_OFFSET0
42337 #   undef JITTER_ARG0
42338 #   undef JITTER_ARGN0
42339 #   undef JITTER_ARGU0
42340 #   undef JITTER_ARGP0
42341 #   undef JITTER_ARGF0
42342 
42343 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42344 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42345 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42346 
42347   }
42348  JITTER_INSTRUCTION_EPILOG_(strace/nR, strace__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42349 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42350 
42351   JITTER_INSTRUCTION_PROLOG_(strref, strref, hot)
42352   {
42353     /* This specialized instruction is not a replacement. */
42354 #   undef JITTER_BRANCH_FAST
42355 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42356 #   undef JITTER_BRANCH_FAST_IF_ZERO
42357 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42358 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42359 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42360 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42361 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
42362 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42363 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
42364 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42365 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
42366 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42367 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
42368 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42369 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
42370 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42371 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
42372 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42373 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
42374 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42375 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42376 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42377 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42378 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42379 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42380 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42381 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42382 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42383 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42384 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42385 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42386 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42387 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42388 #   undef JITTER_BRANCH_FAST_IF_AND
42389 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
42390 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42391 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
42392 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42393 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42394 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42395 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42396 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42397 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42398 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42399 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42400 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42401 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42402 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42403 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42404 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42405 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42406 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42407 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42408 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42409 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42410 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42411 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42412 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42413 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42414 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42415 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42416 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42417 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42418 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       293
42419 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         strref
42420 
42421 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME strref
42422 
42423   /* The residual arity for this instruction does not depend on fast labels. */
42424   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
42425 
42426 
42427 #if defined (JITTER_PROFILE_SAMPLE)
42428   JITTER_PROFILE_SAMPLE_UPDATE
42429      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42430       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42431   /* Force the compiler not move sample-profiling instrumentation
42432      beyond this point; this way the actual user code is timed.
42433      This is still not perfect, as residuals are materialised before
42434      we arrive here, but should be adequate at least for slow VM
42435      instructions. */
42436   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42437 #endif
42438 #if defined (JITTER_PROFILE_COUNT)
42439   /* Notice that, differently from the code above, this
42440      instrumentation code *can* be reordered freely: as long as a
42441      VM instruction is counted, the count increment can be placed
42442      anyehere.  Let GCC move this code and possibly achieve better
42443      throughput by exploiting instruction-level parallelism and
42444      therefore approximate more closely a non-profiled build. */
42445   JITTER_PROFILE_COUNT_UPDATE
42446      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42447       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42448 #endif
42449 
42450 /* User-specified code, instruction-beginning-c part: beginning. */
42451 
42452 /* User-specified code, instruction-beginning-c part: end */
42453 
42454 
42455     /* User code for strref . */
42456 #line 4007 "../../libpoke/pvm.jitter"
42457 
42458      pvm_val string = JITTER_UNDER_TOP_STACK ();
42459      pvm_val index = JITTER_TOP_STACK ();
42460 
42461     if (PVM_VAL_ULONG (index) < 0
42462         || (PVM_VAL_ULONG (index) >=
42463             strlen (PVM_VAL_STR (string))))
42464       PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
42465 
42466     JITTER_PUSH_STACK (PVM_MAKE_UINT (PVM_VAL_STR (string)[PVM_VAL_ULONG (index)],
42467                                       8));
42468 
42469     /* End of the user code for strref . */
42470 
42471 /* User-specified code, instruction-end-c part: beginning. */
42472 
42473 /* User-specified code, instruction-end-c part: end */
42474 
42475     /* Undefine the strref argument macros so they can't be used
42476        by mistake in the instruction body coming next. */
42477 
42478 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42479 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42480 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42481 
42482   }
42483  JITTER_INSTRUCTION_EPILOG_(strref, strref, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42484 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42485 
42486   JITTER_INSTRUCTION_PROLOG_(subi, subi, hot)
42487   {
42488     /* This specialized instruction is not a replacement. */
42489 #   undef JITTER_BRANCH_FAST
42490 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42491 #   undef JITTER_BRANCH_FAST_IF_ZERO
42492 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42493 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42494 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42495 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42496 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
42497 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42498 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
42499 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42500 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
42501 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42502 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
42503 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42504 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
42505 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42506 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
42507 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42508 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
42509 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42510 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42511 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42512 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42513 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42514 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42515 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42516 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42517 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42518 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42519 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42520 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42521 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42522 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42523 #   undef JITTER_BRANCH_FAST_IF_AND
42524 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
42525 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42526 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
42527 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42528 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42529 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42530 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42531 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42532 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42533 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42534 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42535 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42536 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42537 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42538 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42539 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42540 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42541 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42542 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42543 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42544 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42545 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42546 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42547 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42548 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42549 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42550 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42551 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42552 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42553 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       294
42554 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         subi
42555 
42556 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME subi
42557 
42558   /* The residual arity for this instruction does not depend on fast labels. */
42559   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
42560 
42561 
42562 #if defined (JITTER_PROFILE_SAMPLE)
42563   JITTER_PROFILE_SAMPLE_UPDATE
42564      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42565       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42566   /* Force the compiler not move sample-profiling instrumentation
42567      beyond this point; this way the actual user code is timed.
42568      This is still not perfect, as residuals are materialised before
42569      we arrive here, but should be adequate at least for slow VM
42570      instructions. */
42571   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42572 #endif
42573 #if defined (JITTER_PROFILE_COUNT)
42574   /* Notice that, differently from the code above, this
42575      instrumentation code *can* be reordered freely: as long as a
42576      VM instruction is counted, the count increment can be placed
42577      anyehere.  Let GCC move this code and possibly achieve better
42578      throughput by exploiting instruction-level parallelism and
42579      therefore approximate more closely a non-profiled build. */
42580   JITTER_PROFILE_COUNT_UPDATE
42581      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42582       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42583 #endif
42584 
42585 /* User-specified code, instruction-beginning-c part: beginning. */
42586 
42587 /* User-specified code, instruction-beginning-c part: end */
42588 
42589 
42590     /* User code for subi . */
42591 #line 2350 "../../libpoke/pvm.jitter"
42592 
42593     PVM_SUB_SIGNED (INT, int);
42594 
42595     /* End of the user code for subi . */
42596 
42597 /* User-specified code, instruction-end-c part: beginning. */
42598 
42599 /* User-specified code, instruction-end-c part: end */
42600 
42601     /* Undefine the subi argument macros so they can't be used
42602        by mistake in the instruction body coming next. */
42603 
42604 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42605 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42606 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42607 
42608   }
42609  JITTER_INSTRUCTION_EPILOG_(subi, subi, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42610 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42611 
42612   JITTER_INSTRUCTION_PROLOG_(subiu, subiu, hot)
42613   {
42614     /* This specialized instruction is not a replacement. */
42615 #   undef JITTER_BRANCH_FAST
42616 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42617 #   undef JITTER_BRANCH_FAST_IF_ZERO
42618 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42619 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42620 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42621 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42622 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
42623 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42624 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
42625 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42626 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
42627 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42628 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
42629 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42630 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
42631 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42632 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
42633 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42634 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
42635 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42636 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42637 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42638 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42639 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42640 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42641 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42642 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42643 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42644 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42645 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42646 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42647 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42648 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42649 #   undef JITTER_BRANCH_FAST_IF_AND
42650 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
42651 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42652 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
42653 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42654 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42655 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42656 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42657 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42658 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42659 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42660 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42661 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42662 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42663 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42664 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42665 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42666 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42667 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42668 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42669 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42670 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42671 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42672 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42673 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42674 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42675 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42676 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42677 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42678 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42679 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       295
42680 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         subiu
42681 
42682 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME subiu
42683 
42684   /* The residual arity for this instruction does not depend on fast labels. */
42685   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
42686 
42687 
42688 #if defined (JITTER_PROFILE_SAMPLE)
42689   JITTER_PROFILE_SAMPLE_UPDATE
42690      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42691       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42692   /* Force the compiler not move sample-profiling instrumentation
42693      beyond this point; this way the actual user code is timed.
42694      This is still not perfect, as residuals are materialised before
42695      we arrive here, but should be adequate at least for slow VM
42696      instructions. */
42697   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42698 #endif
42699 #if defined (JITTER_PROFILE_COUNT)
42700   /* Notice that, differently from the code above, this
42701      instrumentation code *can* be reordered freely: as long as a
42702      VM instruction is counted, the count increment can be placed
42703      anyehere.  Let GCC move this code and possibly achieve better
42704      throughput by exploiting instruction-level parallelism and
42705      therefore approximate more closely a non-profiled build. */
42706   JITTER_PROFILE_COUNT_UPDATE
42707      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42708       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42709 #endif
42710 
42711 /* User-specified code, instruction-beginning-c part: beginning. */
42712 
42713 /* User-specified code, instruction-beginning-c part: end */
42714 
42715 
42716     /* User code for subiu . */
42717 #line 2363 "../../libpoke/pvm.jitter"
42718 
42719     PVM_BINOP (UINT, UINT, UINT, -);
42720 
42721     /* End of the user code for subiu . */
42722 
42723 /* User-specified code, instruction-end-c part: beginning. */
42724 
42725 /* User-specified code, instruction-end-c part: end */
42726 
42727     /* Undefine the subiu argument macros so they can't be used
42728        by mistake in the instruction body coming next. */
42729 
42730 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42731 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42732 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42733 
42734   }
42735  JITTER_INSTRUCTION_EPILOG_(subiu, subiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42736 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42737 
42738   JITTER_INSTRUCTION_PROLOG_(subl, subl, hot)
42739   {
42740     /* This specialized instruction is not a replacement. */
42741 #   undef JITTER_BRANCH_FAST
42742 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42743 #   undef JITTER_BRANCH_FAST_IF_ZERO
42744 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42745 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42746 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42747 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42748 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
42749 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42750 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
42751 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42752 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
42753 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42754 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
42755 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42756 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
42757 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42758 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
42759 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42760 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
42761 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42762 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42763 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42764 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42765 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42766 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42767 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42768 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42769 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42770 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42771 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42772 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42773 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42774 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42775 #   undef JITTER_BRANCH_FAST_IF_AND
42776 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
42777 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42778 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
42779 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42780 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42781 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42782 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42783 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42784 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42785 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42786 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42787 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42788 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42789 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42790 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42791 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42792 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42793 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42794 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42795 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42796 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42797 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42798 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42799 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42800 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42801 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42802 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42803 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42804 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42805 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       296
42806 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         subl
42807 
42808 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME subl
42809 
42810   /* The residual arity for this instruction does not depend on fast labels. */
42811   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
42812 
42813 
42814 #if defined (JITTER_PROFILE_SAMPLE)
42815   JITTER_PROFILE_SAMPLE_UPDATE
42816      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42817       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42818   /* Force the compiler not move sample-profiling instrumentation
42819      beyond this point; this way the actual user code is timed.
42820      This is still not perfect, as residuals are materialised before
42821      we arrive here, but should be adequate at least for slow VM
42822      instructions. */
42823   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42824 #endif
42825 #if defined (JITTER_PROFILE_COUNT)
42826   /* Notice that, differently from the code above, this
42827      instrumentation code *can* be reordered freely: as long as a
42828      VM instruction is counted, the count increment can be placed
42829      anyehere.  Let GCC move this code and possibly achieve better
42830      throughput by exploiting instruction-level parallelism and
42831      therefore approximate more closely a non-profiled build. */
42832   JITTER_PROFILE_COUNT_UPDATE
42833      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42834       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42835 #endif
42836 
42837 /* User-specified code, instruction-beginning-c part: beginning. */
42838 
42839 /* User-specified code, instruction-beginning-c part: end */
42840 
42841 
42842     /* User code for subl . */
42843 #line 2376 "../../libpoke/pvm.jitter"
42844 
42845     PVM_SUB_SIGNED (LONG, int64_t);
42846 
42847     /* End of the user code for subl . */
42848 
42849 /* User-specified code, instruction-end-c part: beginning. */
42850 
42851 /* User-specified code, instruction-end-c part: end */
42852 
42853     /* Undefine the subl argument macros so they can't be used
42854        by mistake in the instruction body coming next. */
42855 
42856 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42857 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42858 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42859 
42860   }
42861  JITTER_INSTRUCTION_EPILOG_(subl, subl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42862 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42863 
42864   JITTER_INSTRUCTION_PROLOG_(sublu, sublu, hot)
42865   {
42866     /* This specialized instruction is not a replacement. */
42867 #   undef JITTER_BRANCH_FAST
42868 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42869 #   undef JITTER_BRANCH_FAST_IF_ZERO
42870 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42871 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42872 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42873 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42874 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
42875 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42876 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
42877 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42878 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
42879 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42880 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
42881 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42882 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
42883 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42884 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
42885 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42886 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
42887 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42888 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42889 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42890 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42891 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42892 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42893 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42894 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42895 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42896 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42897 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42898 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42899 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42900 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42901 #   undef JITTER_BRANCH_FAST_IF_AND
42902 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
42903 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42904 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
42905 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42906 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42907 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42908 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42909 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42910 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42911 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42912 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42913 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42914 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42915 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42916 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42917 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42918 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42919 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42920 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42921 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42922 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42923 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42924 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42925 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42926 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42927 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42928 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42929 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42930 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42931 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       297
42932 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         sublu
42933 
42934 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME sublu
42935 
42936   /* The residual arity for this instruction does not depend on fast labels. */
42937   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
42938 
42939 
42940 #if defined (JITTER_PROFILE_SAMPLE)
42941   JITTER_PROFILE_SAMPLE_UPDATE
42942      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42943       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42944   /* Force the compiler not move sample-profiling instrumentation
42945      beyond this point; this way the actual user code is timed.
42946      This is still not perfect, as residuals are materialised before
42947      we arrive here, but should be adequate at least for slow VM
42948      instructions. */
42949   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42950 #endif
42951 #if defined (JITTER_PROFILE_COUNT)
42952   /* Notice that, differently from the code above, this
42953      instrumentation code *can* be reordered freely: as long as a
42954      VM instruction is counted, the count increment can be placed
42955      anyehere.  Let GCC move this code and possibly achieve better
42956      throughput by exploiting instruction-level parallelism and
42957      therefore approximate more closely a non-profiled build. */
42958   JITTER_PROFILE_COUNT_UPDATE
42959      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42960       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42961 #endif
42962 
42963 /* User-specified code, instruction-beginning-c part: beginning. */
42964 
42965 /* User-specified code, instruction-beginning-c part: end */
42966 
42967 
42968     /* User code for sublu . */
42969 #line 2389 "../../libpoke/pvm.jitter"
42970 
42971     PVM_BINOP (ULONG, ULONG, ULONG, -);
42972 
42973     /* End of the user code for sublu . */
42974 
42975 /* User-specified code, instruction-end-c part: beginning. */
42976 
42977 /* User-specified code, instruction-end-c part: end */
42978 
42979     /* Undefine the sublu argument macros so they can't be used
42980        by mistake in the instruction body coming next. */
42981 
42982 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42983 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42984 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42985 
42986   }
42987  JITTER_INSTRUCTION_EPILOG_(sublu, sublu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42988 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42989 
42990   JITTER_INSTRUCTION_PROLOG_(substr, substr, hot)
42991   {
42992     /* This specialized instruction is not a replacement. */
42993 #   undef JITTER_BRANCH_FAST
42994 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
42995 #   undef JITTER_BRANCH_FAST_IF_ZERO
42996 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
42997 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42998 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
42999 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43000 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43001 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43002 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43003 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43004 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43005 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43006 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43007 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43008 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43009 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43010 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43011 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43012 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43013 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43014 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43015 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43016 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43017 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43018 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43019 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43020 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43021 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43022 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43023 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43024 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43025 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43026 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43027 #   undef JITTER_BRANCH_FAST_IF_AND
43028 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43029 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43030 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43031 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43032 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43033 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43034 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43035 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43036 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43037 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43038 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43039 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43040 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43041 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43042 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43043 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43044 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43045 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43046 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43047 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43048 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43049 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43050 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43051 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43052 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43053 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43054 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43055 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43056 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43057 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       298
43058 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         substr
43059 
43060 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME substr
43061 
43062   /* The residual arity for this instruction does not depend on fast labels. */
43063   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43064 
43065 
43066 #if defined (JITTER_PROFILE_SAMPLE)
43067   JITTER_PROFILE_SAMPLE_UPDATE
43068      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43069       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43070   /* Force the compiler not move sample-profiling instrumentation
43071      beyond this point; this way the actual user code is timed.
43072      This is still not perfect, as residuals are materialised before
43073      we arrive here, but should be adequate at least for slow VM
43074      instructions. */
43075   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43076 #endif
43077 #if defined (JITTER_PROFILE_COUNT)
43078   /* Notice that, differently from the code above, this
43079      instrumentation code *can* be reordered freely: as long as a
43080      VM instruction is counted, the count increment can be placed
43081      anyehere.  Let GCC move this code and possibly achieve better
43082      throughput by exploiting instruction-level parallelism and
43083      therefore approximate more closely a non-profiled build. */
43084   JITTER_PROFILE_COUNT_UPDATE
43085      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43086       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43087 #endif
43088 
43089 /* User-specified code, instruction-beginning-c part: beginning. */
43090 
43091 /* User-specified code, instruction-beginning-c part: end */
43092 
43093 
43094     /* User code for substr . */
43095 #line 4035 "../../libpoke/pvm.jitter"
43096 
43097     pvm_val str;
43098     char *s;
43099     pvm_val to = JITTER_TOP_STACK ();
43100     pvm_val from = JITTER_UNDER_TOP_STACK ();
43101     size_t slen = PVM_VAL_ULONG (to) - PVM_VAL_ULONG (from);
43102 
43103     JITTER_DROP_STACK ();
43104     str = JITTER_UNDER_TOP_STACK ();
43105     JITTER_PUSH_STACK (to);
43106 
43107     if (PVM_VAL_ULONG (from) >= strlen (PVM_VAL_STR (str))
43108         || PVM_VAL_ULONG (to) > strlen (PVM_VAL_STR (str))
43109         || PVM_VAL_ULONG (from) > PVM_VAL_ULONG (to))
43110         PVM_RAISE_DFL (PVM_E_OUT_OF_BOUNDS);
43111 
43112     s = pvm_alloc (slen + 1);
43113     strncpy (s,
43114              PVM_VAL_STR (str) + PVM_VAL_ULONG (from),
43115              slen);
43116     s[slen] = '\0';
43117 
43118     JITTER_PUSH_STACK (pvm_make_string (s));
43119 
43120     /* End of the user code for substr . */
43121 
43122 /* User-specified code, instruction-end-c part: beginning. */
43123 
43124 /* User-specified code, instruction-end-c part: end */
43125 
43126     /* Undefine the substr argument macros so they can't be used
43127        by mistake in the instruction body coming next. */
43128 
43129 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43130 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43131 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43132 
43133   }
43134  JITTER_INSTRUCTION_EPILOG_(substr, substr, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43135 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43136 
43137   JITTER_INSTRUCTION_PROLOG_(swap, swap, hot)
43138   {
43139     /* This specialized instruction is not a replacement. */
43140 #   undef JITTER_BRANCH_FAST
43141 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
43142 #   undef JITTER_BRANCH_FAST_IF_ZERO
43143 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
43144 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43145 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
43146 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43147 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43148 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43149 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43150 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43151 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43152 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43153 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43154 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43155 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43156 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43157 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43158 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43159 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43160 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43161 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43162 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43163 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43164 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43165 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43166 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43167 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43168 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43169 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43170 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43171 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43172 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43173 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43174 #   undef JITTER_BRANCH_FAST_IF_AND
43175 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43176 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43177 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43178 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43179 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43180 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43181 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43182 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43183 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43184 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43185 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43186 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43187 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43188 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43189 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43190 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43191 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43192 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43193 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43194 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43195 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43196 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43197 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43198 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43199 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43200 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43201 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43202 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43203 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43204 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       299
43205 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         swap
43206 
43207 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME swap
43208 
43209   /* The residual arity for this instruction does not depend on fast labels. */
43210   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43211 
43212 
43213 #if defined (JITTER_PROFILE_SAMPLE)
43214   JITTER_PROFILE_SAMPLE_UPDATE
43215      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43216       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43217   /* Force the compiler not move sample-profiling instrumentation
43218      beyond this point; this way the actual user code is timed.
43219      This is still not perfect, as residuals are materialised before
43220      we arrive here, but should be adequate at least for slow VM
43221      instructions. */
43222   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43223 #endif
43224 #if defined (JITTER_PROFILE_COUNT)
43225   /* Notice that, differently from the code above, this
43226      instrumentation code *can* be reordered freely: as long as a
43227      VM instruction is counted, the count increment can be placed
43228      anyehere.  Let GCC move this code and possibly achieve better
43229      throughput by exploiting instruction-level parallelism and
43230      therefore approximate more closely a non-profiled build. */
43231   JITTER_PROFILE_COUNT_UPDATE
43232      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43233       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43234 #endif
43235 
43236 /* User-specified code, instruction-beginning-c part: beginning. */
43237 
43238 /* User-specified code, instruction-beginning-c part: end */
43239 
43240 
43241     /* User code for swap . */
43242 #line 1985 "../../libpoke/pvm.jitter"
43243 
43244     pvm_val tmp = JITTER_UNDER_TOP_STACK ();
43245     JITTER_UNDER_TOP_STACK () = JITTER_TOP_STACK ();
43246     JITTER_TOP_STACK () = tmp;
43247 
43248     /* End of the user code for swap . */
43249 
43250 /* User-specified code, instruction-end-c part: beginning. */
43251 
43252 /* User-specified code, instruction-end-c part: end */
43253 
43254     /* Undefine the swap argument macros so they can't be used
43255        by mistake in the instruction body coming next. */
43256 
43257 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43258 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43259 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43260 
43261   }
43262  JITTER_INSTRUCTION_EPILOG_(swap, swap, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43263 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43264 
43265   JITTER_INSTRUCTION_PROLOG_(swapgti, swapgti, hot)
43266   {
43267     /* This specialized instruction is not a replacement. */
43268 #   undef JITTER_BRANCH_FAST
43269 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
43270 #   undef JITTER_BRANCH_FAST_IF_ZERO
43271 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
43272 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43273 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
43274 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43275 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43276 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43277 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43278 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43279 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43280 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43281 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43282 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43283 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43284 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43285 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43286 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43287 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43288 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43289 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43290 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43291 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43292 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43293 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43294 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43295 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43296 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43297 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43298 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43299 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43300 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43301 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43302 #   undef JITTER_BRANCH_FAST_IF_AND
43303 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43304 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43305 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43306 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43307 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43308 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43309 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43310 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43311 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43312 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43313 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43314 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43315 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43316 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43317 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43318 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43319 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43320 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43321 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43322 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43323 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43324 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43325 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43326 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43327 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43328 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43329 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43330 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43331 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43332 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       300
43333 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         swapgti
43334 
43335 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME swapgti
43336 
43337   /* The residual arity for this instruction does not depend on fast labels. */
43338   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43339 
43340 
43341 #if defined (JITTER_PROFILE_SAMPLE)
43342   JITTER_PROFILE_SAMPLE_UPDATE
43343      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43344       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43345   /* Force the compiler not move sample-profiling instrumentation
43346      beyond this point; this way the actual user code is timed.
43347      This is still not perfect, as residuals are materialised before
43348      we arrive here, but should be adequate at least for slow VM
43349      instructions. */
43350   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43351 #endif
43352 #if defined (JITTER_PROFILE_COUNT)
43353   /* Notice that, differently from the code above, this
43354      instrumentation code *can* be reordered freely: as long as a
43355      VM instruction is counted, the count increment can be placed
43356      anyehere.  Let GCC move this code and possibly achieve better
43357      throughput by exploiting instruction-level parallelism and
43358      therefore approximate more closely a non-profiled build. */
43359   JITTER_PROFILE_COUNT_UPDATE
43360      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43361       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43362 #endif
43363 
43364 /* User-specified code, instruction-beginning-c part: beginning. */
43365 
43366 /* User-specified code, instruction-beginning-c part: end */
43367 
43368 
43369     /* User code for swapgti . */
43370 #line 3511 "../../libpoke/pvm.jitter"
43371 
43372      pvm_val a = JITTER_UNDER_TOP_STACK ();
43373      pvm_val b = JITTER_TOP_STACK ();
43374      if (PVM_VAL_INT (a) > PVM_VAL_INT (b))
43375      {
43376        JITTER_UNDER_TOP_STACK () = b;
43377        JITTER_TOP_STACK () = a;
43378      }
43379 
43380     /* End of the user code for swapgti . */
43381 
43382 /* User-specified code, instruction-end-c part: beginning. */
43383 
43384 /* User-specified code, instruction-end-c part: end */
43385 
43386     /* Undefine the swapgti argument macros so they can't be used
43387        by mistake in the instruction body coming next. */
43388 
43389 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43390 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43391 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43392 
43393   }
43394  JITTER_INSTRUCTION_EPILOG_(swapgti, swapgti, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43395 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43396 
43397   JITTER_INSTRUCTION_PROLOG_(swapgtiu, swapgtiu, hot)
43398   {
43399     /* This specialized instruction is not a replacement. */
43400 #   undef JITTER_BRANCH_FAST
43401 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
43402 #   undef JITTER_BRANCH_FAST_IF_ZERO
43403 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
43404 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43405 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
43406 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43407 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43408 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43409 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43410 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43411 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43412 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43413 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43414 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43415 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43416 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43417 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43418 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43419 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43420 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43421 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43422 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43423 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43424 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43425 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43426 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43427 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43428 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43429 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43430 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43431 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43432 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43433 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43434 #   undef JITTER_BRANCH_FAST_IF_AND
43435 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43436 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43437 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43438 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43439 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43440 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43441 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43442 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43443 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43444 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43445 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43446 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43447 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43448 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43449 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43450 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43451 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43452 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43453 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43454 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43455 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43456 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43457 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43458 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43459 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43460 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43461 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43462 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43463 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43464 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       301
43465 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         swapgtiu
43466 
43467 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME swapgtiu
43468 
43469   /* The residual arity for this instruction does not depend on fast labels. */
43470   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43471 
43472 
43473 #if defined (JITTER_PROFILE_SAMPLE)
43474   JITTER_PROFILE_SAMPLE_UPDATE
43475      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43476       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43477   /* Force the compiler not move sample-profiling instrumentation
43478      beyond this point; this way the actual user code is timed.
43479      This is still not perfect, as residuals are materialised before
43480      we arrive here, but should be adequate at least for slow VM
43481      instructions. */
43482   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43483 #endif
43484 #if defined (JITTER_PROFILE_COUNT)
43485   /* Notice that, differently from the code above, this
43486      instrumentation code *can* be reordered freely: as long as a
43487      VM instruction is counted, the count increment can be placed
43488      anyehere.  Let GCC move this code and possibly achieve better
43489      throughput by exploiting instruction-level parallelism and
43490      therefore approximate more closely a non-profiled build. */
43491   JITTER_PROFILE_COUNT_UPDATE
43492      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43493       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43494 #endif
43495 
43496 /* User-specified code, instruction-beginning-c part: beginning. */
43497 
43498 /* User-specified code, instruction-beginning-c part: end */
43499 
43500 
43501     /* User code for swapgtiu . */
43502 #line 3530 "../../libpoke/pvm.jitter"
43503 
43504      pvm_val a = JITTER_UNDER_TOP_STACK ();
43505      pvm_val b = JITTER_TOP_STACK ();
43506      if (PVM_VAL_UINT (a) > PVM_VAL_UINT (b))
43507      {
43508        JITTER_UNDER_TOP_STACK () = b;
43509        JITTER_TOP_STACK () = a;
43510      }
43511 
43512     /* End of the user code for swapgtiu . */
43513 
43514 /* User-specified code, instruction-end-c part: beginning. */
43515 
43516 /* User-specified code, instruction-end-c part: end */
43517 
43518     /* Undefine the swapgtiu argument macros so they can't be used
43519        by mistake in the instruction body coming next. */
43520 
43521 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43522 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43523 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43524 
43525   }
43526  JITTER_INSTRUCTION_EPILOG_(swapgtiu, swapgtiu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43527 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43528 
43529   JITTER_INSTRUCTION_PROLOG_(swapgtl, swapgtl, hot)
43530   {
43531     /* This specialized instruction is not a replacement. */
43532 #   undef JITTER_BRANCH_FAST
43533 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
43534 #   undef JITTER_BRANCH_FAST_IF_ZERO
43535 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
43536 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43537 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
43538 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43539 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43540 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43541 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43542 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43543 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43544 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43545 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43546 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43547 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43548 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43549 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43550 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43551 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43552 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43553 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43554 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43555 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43556 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43557 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43558 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43559 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43560 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43561 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43562 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43563 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43564 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43565 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43566 #   undef JITTER_BRANCH_FAST_IF_AND
43567 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43568 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43569 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43570 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43571 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43572 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43573 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43574 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43575 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43576 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43577 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43578 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43579 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43580 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43581 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43582 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43583 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43584 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43585 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43586 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43587 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43588 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43589 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43590 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43591 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43592 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43593 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43594 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43595 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43596 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       302
43597 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         swapgtl
43598 
43599 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME swapgtl
43600 
43601   /* The residual arity for this instruction does not depend on fast labels. */
43602   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43603 
43604 
43605 #if defined (JITTER_PROFILE_SAMPLE)
43606   JITTER_PROFILE_SAMPLE_UPDATE
43607      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43608       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43609   /* Force the compiler not move sample-profiling instrumentation
43610      beyond this point; this way the actual user code is timed.
43611      This is still not perfect, as residuals are materialised before
43612      we arrive here, but should be adequate at least for slow VM
43613      instructions. */
43614   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43615 #endif
43616 #if defined (JITTER_PROFILE_COUNT)
43617   /* Notice that, differently from the code above, this
43618      instrumentation code *can* be reordered freely: as long as a
43619      VM instruction is counted, the count increment can be placed
43620      anyehere.  Let GCC move this code and possibly achieve better
43621      throughput by exploiting instruction-level parallelism and
43622      therefore approximate more closely a non-profiled build. */
43623   JITTER_PROFILE_COUNT_UPDATE
43624      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43625       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43626 #endif
43627 
43628 /* User-specified code, instruction-beginning-c part: beginning. */
43629 
43630 /* User-specified code, instruction-beginning-c part: end */
43631 
43632 
43633     /* User code for swapgtl . */
43634 #line 3549 "../../libpoke/pvm.jitter"
43635 
43636      pvm_val a = JITTER_UNDER_TOP_STACK ();
43637      pvm_val b = JITTER_TOP_STACK ();
43638      if (PVM_VAL_LONG (a) > PVM_VAL_LONG (b))
43639      {
43640        JITTER_UNDER_TOP_STACK () = b;
43641        JITTER_TOP_STACK () = a;
43642      }
43643 
43644     /* End of the user code for swapgtl . */
43645 
43646 /* User-specified code, instruction-end-c part: beginning. */
43647 
43648 /* User-specified code, instruction-end-c part: end */
43649 
43650     /* Undefine the swapgtl argument macros so they can't be used
43651        by mistake in the instruction body coming next. */
43652 
43653 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43654 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43655 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43656 
43657   }
43658  JITTER_INSTRUCTION_EPILOG_(swapgtl, swapgtl, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43659 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43660 
43661   JITTER_INSTRUCTION_PROLOG_(swapgtlu, swapgtlu, hot)
43662   {
43663     /* This specialized instruction is not a replacement. */
43664 #   undef JITTER_BRANCH_FAST
43665 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
43666 #   undef JITTER_BRANCH_FAST_IF_ZERO
43667 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
43668 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43669 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
43670 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43671 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43672 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43673 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43674 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43675 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43676 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43677 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43678 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43679 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43680 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43681 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43682 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43683 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43684 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43685 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43686 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43687 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43688 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43689 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43690 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43691 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43692 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43693 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43694 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43695 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43696 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43697 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43698 #   undef JITTER_BRANCH_FAST_IF_AND
43699 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43700 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43701 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43702 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43703 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43704 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43705 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43706 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43707 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43708 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43709 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43710 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43711 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43712 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43713 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43714 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43715 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43716 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43717 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43718 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43719 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43720 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43721 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43722 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43723 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43724 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43725 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43726 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43727 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43728 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       303
43729 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         swapgtlu
43730 
43731 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME swapgtlu
43732 
43733   /* The residual arity for this instruction does not depend on fast labels. */
43734   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43735 
43736 
43737 #if defined (JITTER_PROFILE_SAMPLE)
43738   JITTER_PROFILE_SAMPLE_UPDATE
43739      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43740       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43741   /* Force the compiler not move sample-profiling instrumentation
43742      beyond this point; this way the actual user code is timed.
43743      This is still not perfect, as residuals are materialised before
43744      we arrive here, but should be adequate at least for slow VM
43745      instructions. */
43746   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43747 #endif
43748 #if defined (JITTER_PROFILE_COUNT)
43749   /* Notice that, differently from the code above, this
43750      instrumentation code *can* be reordered freely: as long as a
43751      VM instruction is counted, the count increment can be placed
43752      anyehere.  Let GCC move this code and possibly achieve better
43753      throughput by exploiting instruction-level parallelism and
43754      therefore approximate more closely a non-profiled build. */
43755   JITTER_PROFILE_COUNT_UPDATE
43756      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43757       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43758 #endif
43759 
43760 /* User-specified code, instruction-beginning-c part: beginning. */
43761 
43762 /* User-specified code, instruction-beginning-c part: end */
43763 
43764 
43765     /* User code for swapgtlu . */
43766 #line 3568 "../../libpoke/pvm.jitter"
43767 
43768      pvm_val a = JITTER_UNDER_TOP_STACK ();
43769      pvm_val b = JITTER_TOP_STACK ();
43770      if (PVM_VAL_ULONG (a) > PVM_VAL_ULONG (b))
43771      {
43772        JITTER_UNDER_TOP_STACK () = b;
43773        JITTER_TOP_STACK () = a;
43774      }
43775 
43776     /* End of the user code for swapgtlu . */
43777 
43778 /* User-specified code, instruction-end-c part: beginning. */
43779 
43780 /* User-specified code, instruction-end-c part: end */
43781 
43782     /* Undefine the swapgtlu argument macros so they can't be used
43783        by mistake in the instruction body coming next. */
43784 
43785 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43786 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43787 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43788 
43789   }
43790  JITTER_INSTRUCTION_EPILOG_(swapgtlu, swapgtlu, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43791 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43792 
43793   JITTER_INSTRUCTION_PROLOG_(sync, sync, hot)
43794   {
43795     /* This specialized instruction is not a replacement. */
43796 #   undef JITTER_BRANCH_FAST
43797 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
43798 #   undef JITTER_BRANCH_FAST_IF_ZERO
43799 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
43800 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43801 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
43802 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43803 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43804 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43805 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43806 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43807 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43808 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43809 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43810 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43811 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43812 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43813 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43814 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43815 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43816 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43817 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43818 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43819 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43820 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43821 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43822 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43823 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43824 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43825 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43826 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43827 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43828 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43829 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43830 #   undef JITTER_BRANCH_FAST_IF_AND
43831 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43832 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43833 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43834 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43835 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43836 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43837 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43838 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43839 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43840 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43841 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43842 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43843 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43844 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43845 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43846 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43847 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43848 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43849 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43850 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43851 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43852 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43853 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43854 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43855 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43856 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43857 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43858 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43859 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43860 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       304
43861 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         sync
43862 
43863 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME sync
43864 
43865   /* The residual arity for this instruction does not depend on fast labels. */
43866   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43867 
43868 
43869 #if defined (JITTER_PROFILE_SAMPLE)
43870   JITTER_PROFILE_SAMPLE_UPDATE
43871      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43872       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43873   /* Force the compiler not move sample-profiling instrumentation
43874      beyond this point; this way the actual user code is timed.
43875      This is still not perfect, as residuals are materialised before
43876      we arrive here, but should be adequate at least for slow VM
43877      instructions. */
43878   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43879 #endif
43880 #if defined (JITTER_PROFILE_COUNT)
43881   /* Notice that, differently from the code above, this
43882      instrumentation code *can* be reordered freely: as long as a
43883      VM instruction is counted, the count increment can be placed
43884      anyehere.  Let GCC move this code and possibly achieve better
43885      throughput by exploiting instruction-level parallelism and
43886      therefore approximate more closely a non-profiled build. */
43887   JITTER_PROFILE_COUNT_UPDATE
43888      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43889       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43890 #endif
43891 
43892 /* User-specified code, instruction-beginning-c part: beginning. */
43893 
43894 /* User-specified code, instruction-beginning-c part: end */
43895 
43896 
43897     /* User code for sync . */
43898 #line 1325 "../../libpoke/pvm.jitter"
43899 
43900     /* XXX for now we treat all signals the same way.
43901        As soon as we support exception arguments, we shall
43902        pass the mask of signals to the signal handler.  */
43903     if (JITTER_PENDING_NOTIFICATIONS)
43904       PVM_RAISE_DFL (PVM_E_SIGNAL);
43905 
43906     /* End of the user code for sync . */
43907 
43908 /* User-specified code, instruction-end-c part: beginning. */
43909 
43910 /* User-specified code, instruction-end-c part: end */
43911 
43912     /* Undefine the sync argument macros so they can't be used
43913        by mistake in the instruction body coming next. */
43914 
43915 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43916 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43917 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43918 
43919   }
43920  JITTER_INSTRUCTION_EPILOG_(sync, sync, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43921 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43922 
43923   JITTER_INSTRUCTION_PROLOG_(time, time, hot)
43924   {
43925     /* This specialized instruction is not a replacement. */
43926 #   undef JITTER_BRANCH_FAST
43927 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
43928 #   undef JITTER_BRANCH_FAST_IF_ZERO
43929 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
43930 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43931 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
43932 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43933 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
43934 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43935 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
43936 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43937 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
43938 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43939 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
43940 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43941 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
43942 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43943 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
43944 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43945 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
43946 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43947 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43948 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43949 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43950 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43951 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43952 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43953 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43954 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43955 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43956 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43957 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43958 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43959 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43960 #   undef JITTER_BRANCH_FAST_IF_AND
43961 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
43962 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43963 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
43964 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43965 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43966 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43967 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43968 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43969 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43970 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43971 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43972 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43973 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43974 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43975 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43976 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43977 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43978 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43979 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43980 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43981 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43982 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43983 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43984 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43985 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43986 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43987 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43988 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43989 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43990 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       305
43991 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         time
43992 
43993 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME time
43994 
43995   /* The residual arity for this instruction does not depend on fast labels. */
43996   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
43997 
43998 
43999 #if defined (JITTER_PROFILE_SAMPLE)
44000   JITTER_PROFILE_SAMPLE_UPDATE
44001      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44002       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44003   /* Force the compiler not move sample-profiling instrumentation
44004      beyond this point; this way the actual user code is timed.
44005      This is still not perfect, as residuals are materialised before
44006      we arrive here, but should be adequate at least for slow VM
44007      instructions. */
44008   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44009 #endif
44010 #if defined (JITTER_PROFILE_COUNT)
44011   /* Notice that, differently from the code above, this
44012      instrumentation code *can* be reordered freely: as long as a
44013      VM instruction is counted, the count increment can be placed
44014      anyehere.  Let GCC move this code and possibly achieve better
44015      throughput by exploiting instruction-level parallelism and
44016      therefore approximate more closely a non-profiled build. */
44017   JITTER_PROFILE_COUNT_UPDATE
44018      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44019       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44020 #endif
44021 
44022 /* User-specified code, instruction-beginning-c part: beginning. */
44023 
44024 /* User-specified code, instruction-beginning-c part: end */
44025 
44026 
44027     /* User code for time . */
44028 #line 5740 "../../libpoke/pvm.jitter"
44029 
44030     struct timespec ts;
44031     pvm_val arr = pvm_make_array (PVM_MAKE_ULONG (2, 64),
44032                                   pvm_make_integral_type (64, 1));
44033 
44034     gettime (&ts);
44035     (void) pvm_array_insert (arr, PVM_MAKE_LONG (0, 64),
44036                              PVM_MAKE_LONG (ts.tv_sec, 64));
44037     (void) pvm_array_insert (arr, PVM_MAKE_LONG (1, 64),
44038                              PVM_MAKE_LONG (ts.tv_nsec, 64));
44039 
44040     JITTER_PUSH_STACK (arr);
44041 
44042     /* End of the user code for time . */
44043 
44044 /* User-specified code, instruction-end-c part: beginning. */
44045 
44046 /* User-specified code, instruction-end-c part: end */
44047 
44048     /* Undefine the time argument macros so they can't be used
44049        by mistake in the instruction body coming next. */
44050 
44051 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44052 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44053 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44054 
44055   }
44056  JITTER_INSTRUCTION_EPILOG_(time, time, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44057 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44058 
44059   JITTER_INSTRUCTION_PROLOG_(tor, tor, hot)
44060   {
44061     /* This specialized instruction is not a replacement. */
44062 #   undef JITTER_BRANCH_FAST
44063 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44064 #   undef JITTER_BRANCH_FAST_IF_ZERO
44065 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44066 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44067 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44068 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44069 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44070 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44071 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44072 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44073 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44074 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44075 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44076 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44077 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44078 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44079 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44080 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44081 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44082 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44083 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44084 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44085 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44086 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44087 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44088 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44089 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44090 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44091 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44092 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44093 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44094 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44095 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44096 #   undef JITTER_BRANCH_FAST_IF_AND
44097 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44098 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44099 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44100 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44101 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44102 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44103 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44104 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44105 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44106 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44107 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44108 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44109 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44110 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44111 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44112 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44113 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44114 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44115 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44116 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44117 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44118 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44119 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44120 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44121 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44122 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44123 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44124 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44125 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44126 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       306
44127 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tor
44128 
44129 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tor
44130 
44131   /* The residual arity for this instruction does not depend on fast labels. */
44132   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
44133 
44134 
44135 #if defined (JITTER_PROFILE_SAMPLE)
44136   JITTER_PROFILE_SAMPLE_UPDATE
44137      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44138       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44139   /* Force the compiler not move sample-profiling instrumentation
44140      beyond this point; this way the actual user code is timed.
44141      This is still not perfect, as residuals are materialised before
44142      we arrive here, but should be adequate at least for slow VM
44143      instructions. */
44144   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44145 #endif
44146 #if defined (JITTER_PROFILE_COUNT)
44147   /* Notice that, differently from the code above, this
44148      instrumentation code *can* be reordered freely: as long as a
44149      VM instruction is counted, the count increment can be placed
44150      anyehere.  Let GCC move this code and possibly achieve better
44151      throughput by exploiting instruction-level parallelism and
44152      therefore approximate more closely a non-profiled build. */
44153   JITTER_PROFILE_COUNT_UPDATE
44154      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44155       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44156 #endif
44157 
44158 /* User-specified code, instruction-beginning-c part: beginning. */
44159 
44160 /* User-specified code, instruction-beginning-c part: end */
44161 
44162 
44163     /* User code for tor . */
44164 #line 2249 "../../libpoke/pvm.jitter"
44165 
44166     JITTER_PUSH_RETURNSTACK (JITTER_TOP_STACK ());
44167     JITTER_DROP_STACK ();
44168 
44169     /* End of the user code for tor . */
44170 
44171 /* User-specified code, instruction-end-c part: beginning. */
44172 
44173 /* User-specified code, instruction-end-c part: end */
44174 
44175     /* Undefine the tor argument macros so they can't be used
44176        by mistake in the instruction body coming next. */
44177 
44178 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44179 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44180 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44181 
44182   }
44183  JITTER_INSTRUCTION_EPILOG_(tor, tor, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44184 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44185 
44186   JITTER_INSTRUCTION_PROLOG_(tuck, tuck, hot)
44187   {
44188     /* This specialized instruction is not a replacement. */
44189 #   undef JITTER_BRANCH_FAST
44190 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44191 #   undef JITTER_BRANCH_FAST_IF_ZERO
44192 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44193 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44194 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44195 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44196 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44197 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44198 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44199 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44200 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44201 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44202 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44203 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44204 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44205 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44206 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44207 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44208 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44209 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44210 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44211 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44212 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44213 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44214 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44215 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44216 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44217 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44218 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44219 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44220 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44221 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44222 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44223 #   undef JITTER_BRANCH_FAST_IF_AND
44224 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44225 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44226 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44227 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44228 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44229 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44230 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44231 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44232 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44233 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44234 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44235 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44236 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44237 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44238 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44239 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44240 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44241 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44242 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44243 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44244 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44245 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44246 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44247 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44248 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44249 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44250 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44251 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44252 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44253 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       307
44254 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tuck
44255 
44256 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tuck
44257 
44258   /* The residual arity for this instruction does not depend on fast labels. */
44259   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
44260 
44261 
44262 #if defined (JITTER_PROFILE_SAMPLE)
44263   JITTER_PROFILE_SAMPLE_UPDATE
44264      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44265       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44266   /* Force the compiler not move sample-profiling instrumentation
44267      beyond this point; this way the actual user code is timed.
44268      This is still not perfect, as residuals are materialised before
44269      we arrive here, but should be adequate at least for slow VM
44270      instructions. */
44271   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44272 #endif
44273 #if defined (JITTER_PROFILE_COUNT)
44274   /* Notice that, differently from the code above, this
44275      instrumentation code *can* be reordered freely: as long as a
44276      VM instruction is counted, the count increment can be placed
44277      anyehere.  Let GCC move this code and possibly achieve better
44278      throughput by exploiting instruction-level parallelism and
44279      therefore approximate more closely a non-profiled build. */
44280   JITTER_PROFILE_COUNT_UPDATE
44281      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44282       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44283 #endif
44284 
44285 /* User-specified code, instruction-beginning-c part: beginning. */
44286 
44287 /* User-specified code, instruction-beginning-c part: end */
44288 
44289 
44290     /* User code for tuck . */
44291 #line 2088 "../../libpoke/pvm.jitter"
44292 
44293     JITTER_TUCK_STACK ();
44294 
44295     /* End of the user code for tuck . */
44296 
44297 /* User-specified code, instruction-end-c part: beginning. */
44298 
44299 /* User-specified code, instruction-end-c part: end */
44300 
44301     /* Undefine the tuck argument macros so they can't be used
44302        by mistake in the instruction body coming next. */
44303 
44304 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44305 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44306 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44307 
44308   }
44309  JITTER_INSTRUCTION_EPILOG_(tuck, tuck, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44310 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44311 
44312   JITTER_INSTRUCTION_PROLOG_(tyagetb, tyagetb, hot)
44313   {
44314     /* This specialized instruction is not a replacement. */
44315 #   undef JITTER_BRANCH_FAST
44316 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44317 #   undef JITTER_BRANCH_FAST_IF_ZERO
44318 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44319 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44320 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44321 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44322 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44323 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44324 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44325 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44326 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44327 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44328 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44329 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44330 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44331 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44332 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44333 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44334 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44335 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44336 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44337 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44338 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44339 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44340 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44341 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44342 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44343 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44344 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44345 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44346 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44347 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44348 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44349 #   undef JITTER_BRANCH_FAST_IF_AND
44350 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44351 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44352 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44353 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44354 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44355 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44356 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44357 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44358 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44359 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44360 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44361 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44362 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44363 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44364 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44365 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44366 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44367 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44368 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44369 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44370 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44371 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44372 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44373 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44374 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44375 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44376 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44377 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44378 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44379 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       308
44380 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tyagetb
44381 
44382 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tyagetb
44383 
44384   /* The residual arity for this instruction does not depend on fast labels. */
44385   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
44386 
44387 
44388 #if defined (JITTER_PROFILE_SAMPLE)
44389   JITTER_PROFILE_SAMPLE_UPDATE
44390      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44391       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44392   /* Force the compiler not move sample-profiling instrumentation
44393      beyond this point; this way the actual user code is timed.
44394      This is still not perfect, as residuals are materialised before
44395      we arrive here, but should be adequate at least for slow VM
44396      instructions. */
44397   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44398 #endif
44399 #if defined (JITTER_PROFILE_COUNT)
44400   /* Notice that, differently from the code above, this
44401      instrumentation code *can* be reordered freely: as long as a
44402      VM instruction is counted, the count increment can be placed
44403      anyehere.  Let GCC move this code and possibly achieve better
44404      throughput by exploiting instruction-level parallelism and
44405      therefore approximate more closely a non-profiled build. */
44406   JITTER_PROFILE_COUNT_UPDATE
44407      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44408       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44409 #endif
44410 
44411 /* User-specified code, instruction-beginning-c part: beginning. */
44412 
44413 /* User-specified code, instruction-beginning-c part: end */
44414 
44415 
44416     /* User code for tyagetb . */
44417 #line 5132 "../../libpoke/pvm.jitter"
44418 
44419     JITTER_PUSH_STACK (PVM_VAL_TYP_A_BOUND (JITTER_TOP_STACK ()));
44420 
44421     /* End of the user code for tyagetb . */
44422 
44423 /* User-specified code, instruction-end-c part: beginning. */
44424 
44425 /* User-specified code, instruction-end-c part: end */
44426 
44427     /* Undefine the tyagetb argument macros so they can't be used
44428        by mistake in the instruction body coming next. */
44429 
44430 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44431 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44432 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44433 
44434   }
44435  JITTER_INSTRUCTION_EPILOG_(tyagetb, tyagetb, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44436 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44437 
44438   JITTER_INSTRUCTION_PROLOG_(tyagett, tyagett, hot)
44439   {
44440     /* This specialized instruction is not a replacement. */
44441 #   undef JITTER_BRANCH_FAST
44442 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44443 #   undef JITTER_BRANCH_FAST_IF_ZERO
44444 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44445 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44446 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44447 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44448 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44449 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44450 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44451 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44452 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44453 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44454 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44455 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44456 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44457 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44458 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44459 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44460 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44461 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44462 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44463 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44464 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44465 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44466 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44467 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44468 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44469 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44470 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44471 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44472 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44473 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44474 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44475 #   undef JITTER_BRANCH_FAST_IF_AND
44476 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44477 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44478 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44479 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44480 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44481 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44482 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44483 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44484 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44485 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44486 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44487 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44488 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44489 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44490 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44491 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44492 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44493 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44494 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44495 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44496 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44497 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44498 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44499 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44500 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44501 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44502 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44503 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44504 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44505 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       309
44506 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tyagett
44507 
44508 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tyagett
44509 
44510   /* The residual arity for this instruction does not depend on fast labels. */
44511   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
44512 
44513 
44514 #if defined (JITTER_PROFILE_SAMPLE)
44515   JITTER_PROFILE_SAMPLE_UPDATE
44516      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44517       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44518   /* Force the compiler not move sample-profiling instrumentation
44519      beyond this point; this way the actual user code is timed.
44520      This is still not perfect, as residuals are materialised before
44521      we arrive here, but should be adequate at least for slow VM
44522      instructions. */
44523   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44524 #endif
44525 #if defined (JITTER_PROFILE_COUNT)
44526   /* Notice that, differently from the code above, this
44527      instrumentation code *can* be reordered freely: as long as a
44528      VM instruction is counted, the count increment can be placed
44529      anyehere.  Let GCC move this code and possibly achieve better
44530      throughput by exploiting instruction-level parallelism and
44531      therefore approximate more closely a non-profiled build. */
44532   JITTER_PROFILE_COUNT_UPDATE
44533      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44534       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44535 #endif
44536 
44537 /* User-specified code, instruction-beginning-c part: beginning. */
44538 
44539 /* User-specified code, instruction-beginning-c part: end */
44540 
44541 
44542     /* User code for tyagett . */
44543 #line 5120 "../../libpoke/pvm.jitter"
44544 
44545     JITTER_PUSH_STACK (PVM_VAL_TYP_A_ETYPE (JITTER_TOP_STACK ()));
44546 
44547     /* End of the user code for tyagett . */
44548 
44549 /* User-specified code, instruction-end-c part: beginning. */
44550 
44551 /* User-specified code, instruction-end-c part: end */
44552 
44553     /* Undefine the tyagett argument macros so they can't be used
44554        by mistake in the instruction body coming next. */
44555 
44556 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44557 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44558 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44559 
44560   }
44561  JITTER_INSTRUCTION_EPILOG_(tyagett, tyagett, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44562 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44563 
44564   JITTER_INSTRUCTION_PROLOG_(tyisc, tyisc, hot)
44565   {
44566     /* This specialized instruction is not a replacement. */
44567 #   undef JITTER_BRANCH_FAST
44568 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44569 #   undef JITTER_BRANCH_FAST_IF_ZERO
44570 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44571 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44572 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44573 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44574 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44575 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44576 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44577 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44578 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44579 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44580 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44581 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44582 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44583 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44584 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44585 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44586 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44587 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44588 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44589 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44590 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44591 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44592 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44593 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44594 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44595 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44596 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44597 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44598 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44599 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44600 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44601 #   undef JITTER_BRANCH_FAST_IF_AND
44602 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44603 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44604 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44605 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44606 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44607 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44608 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44609 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44610 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44611 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44612 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44613 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44614 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44615 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44616 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44617 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44618 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44619 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44620 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44621 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44622 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44623 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44624 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44625 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44626 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44627 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44628 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44629 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44630 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44631 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       310
44632 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tyisc
44633 
44634 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tyisc
44635 
44636   /* The residual arity for this instruction does not depend on fast labels. */
44637   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
44638 
44639 
44640 #if defined (JITTER_PROFILE_SAMPLE)
44641   JITTER_PROFILE_SAMPLE_UPDATE
44642      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44643       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44644   /* Force the compiler not move sample-profiling instrumentation
44645      beyond this point; this way the actual user code is timed.
44646      This is still not perfect, as residuals are materialised before
44647      we arrive here, but should be adequate at least for slow VM
44648      instructions. */
44649   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44650 #endif
44651 #if defined (JITTER_PROFILE_COUNT)
44652   /* Notice that, differently from the code above, this
44653      instrumentation code *can* be reordered freely: as long as a
44654      VM instruction is counted, the count increment can be placed
44655      anyehere.  Let GCC move this code and possibly achieve better
44656      throughput by exploiting instruction-level parallelism and
44657      therefore approximate more closely a non-profiled build. */
44658   JITTER_PROFILE_COUNT_UPDATE
44659      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44660       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44661 #endif
44662 
44663 /* User-specified code, instruction-beginning-c part: beginning. */
44664 
44665 /* User-specified code, instruction-beginning-c part: end */
44666 
44667 
44668     /* User code for tyisc . */
44669 #line 5006 "../../libpoke/pvm.jitter"
44670 
44671     JITTER_PUSH_STACK (PVM_MAKE_INT (PVM_IS_CLS (JITTER_TOP_STACK ()), 32));
44672 
44673     /* End of the user code for tyisc . */
44674 
44675 /* User-specified code, instruction-end-c part: beginning. */
44676 
44677 /* User-specified code, instruction-end-c part: end */
44678 
44679     /* Undefine the tyisc argument macros so they can't be used
44680        by mistake in the instruction body coming next. */
44681 
44682 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44683 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44684 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44685 
44686   }
44687  JITTER_INSTRUCTION_EPILOG_(tyisc, tyisc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44688 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44689 
44690   JITTER_INSTRUCTION_PROLOG_(tyissct, tyissct, hot)
44691   {
44692     /* This specialized instruction is not a replacement. */
44693 #   undef JITTER_BRANCH_FAST
44694 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44695 #   undef JITTER_BRANCH_FAST_IF_ZERO
44696 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44697 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44698 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44699 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44700 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44701 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44702 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44703 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44704 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44705 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44706 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44707 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44708 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44709 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44710 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44711 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44712 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44713 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44714 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44715 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44716 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44717 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44718 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44719 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44720 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44721 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44722 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44723 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44724 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44725 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44726 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44727 #   undef JITTER_BRANCH_FAST_IF_AND
44728 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44729 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44730 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44731 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44732 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44733 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44734 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44735 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44736 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44737 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44738 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44739 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44740 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44741 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44742 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44743 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44744 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44745 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44746 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44747 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44748 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44749 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44750 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44751 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44752 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44753 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44754 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44755 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44756 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44757 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       311
44758 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tyissct
44759 
44760 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tyissct
44761 
44762   /* The residual arity for this instruction does not depend on fast labels. */
44763   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
44764 
44765 
44766 #if defined (JITTER_PROFILE_SAMPLE)
44767   JITTER_PROFILE_SAMPLE_UPDATE
44768      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44769       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44770   /* Force the compiler not move sample-profiling instrumentation
44771      beyond this point; this way the actual user code is timed.
44772      This is still not perfect, as residuals are materialised before
44773      we arrive here, but should be adequate at least for slow VM
44774      instructions. */
44775   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44776 #endif
44777 #if defined (JITTER_PROFILE_COUNT)
44778   /* Notice that, differently from the code above, this
44779      instrumentation code *can* be reordered freely: as long as a
44780      VM instruction is counted, the count increment can be placed
44781      anyehere.  Let GCC move this code and possibly achieve better
44782      throughput by exploiting instruction-level parallelism and
44783      therefore approximate more closely a non-profiled build. */
44784   JITTER_PROFILE_COUNT_UPDATE
44785      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44786       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44787 #endif
44788 
44789 /* User-specified code, instruction-beginning-c part: beginning. */
44790 
44791 /* User-specified code, instruction-beginning-c part: end */
44792 
44793 
44794     /* User code for tyissct . */
44795 #line 5019 "../../libpoke/pvm.jitter"
44796 
44797     JITTER_PUSH_STACK (PVM_MAKE_INT (PVM_IS_SCT (JITTER_TOP_STACK ()), 32));
44798 
44799     /* End of the user code for tyissct . */
44800 
44801 /* User-specified code, instruction-end-c part: beginning. */
44802 
44803 /* User-specified code, instruction-end-c part: end */
44804 
44805     /* Undefine the tyissct argument macros so they can't be used
44806        by mistake in the instruction body coming next. */
44807 
44808 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44809 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44810 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44811 
44812   }
44813  JITTER_INSTRUCTION_EPILOG_(tyissct, tyissct, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44814 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44815 
44816   JITTER_INSTRUCTION_PROLOG_(typof, typof, hot)
44817   {
44818     /* This specialized instruction is not a replacement. */
44819 #   undef JITTER_BRANCH_FAST
44820 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44821 #   undef JITTER_BRANCH_FAST_IF_ZERO
44822 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44823 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44824 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44825 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44826 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44827 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44828 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44829 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44830 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44831 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44832 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44833 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44834 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44835 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44836 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44837 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44838 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44839 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44840 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44841 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44842 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44843 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44844 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44845 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44846 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44847 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44848 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44849 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44850 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44851 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44852 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44853 #   undef JITTER_BRANCH_FAST_IF_AND
44854 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44855 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44856 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44857 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44858 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44859 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44860 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44861 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44862 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44863 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44864 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44865 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44866 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44867 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44868 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44869 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44870 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44871 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44872 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44873 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44874 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44875 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44876 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44877 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44878 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44879 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44880 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44881 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44882 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44883 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       312
44884 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         typof
44885 
44886 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME typof
44887 
44888   /* The residual arity for this instruction does not depend on fast labels. */
44889   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
44890 
44891 
44892 #if defined (JITTER_PROFILE_SAMPLE)
44893   JITTER_PROFILE_SAMPLE_UPDATE
44894      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44895       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44896   /* Force the compiler not move sample-profiling instrumentation
44897      beyond this point; this way the actual user code is timed.
44898      This is still not perfect, as residuals are materialised before
44899      we arrive here, but should be adequate at least for slow VM
44900      instructions. */
44901   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44902 #endif
44903 #if defined (JITTER_PROFILE_COUNT)
44904   /* Notice that, differently from the code above, this
44905      instrumentation code *can* be reordered freely: as long as a
44906      VM instruction is counted, the count increment can be placed
44907      anyehere.  Let GCC move this code and possibly achieve better
44908      throughput by exploiting instruction-level parallelism and
44909      therefore approximate more closely a non-profiled build. */
44910   JITTER_PROFILE_COUNT_UPDATE
44911      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44912       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44913 #endif
44914 
44915 /* User-specified code, instruction-beginning-c part: beginning. */
44916 
44917 /* User-specified code, instruction-beginning-c part: end */
44918 
44919 
44920     /* User code for typof . */
44921 #line 4993 "../../libpoke/pvm.jitter"
44922 
44923     JITTER_PUSH_STACK (pvm_typeof (JITTER_TOP_STACK ()));
44924 
44925     /* End of the user code for typof . */
44926 
44927 /* User-specified code, instruction-end-c part: beginning. */
44928 
44929 /* User-specified code, instruction-end-c part: end */
44930 
44931     /* Undefine the typof argument macros so they can't be used
44932        by mistake in the instruction body coming next. */
44933 
44934 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44935 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44936 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44937 
44938   }
44939  JITTER_INSTRUCTION_EPILOG_(typof, typof, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44940 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44941 
44942   JITTER_INSTRUCTION_PROLOG_(tysctn, tysctn, hot)
44943   {
44944     /* This specialized instruction is not a replacement. */
44945 #   undef JITTER_BRANCH_FAST
44946 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
44947 #   undef JITTER_BRANCH_FAST_IF_ZERO
44948 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
44949 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44950 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
44951 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44952 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
44953 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44954 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
44955 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44956 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
44957 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44958 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
44959 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44960 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
44961 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44962 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
44963 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44964 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
44965 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44966 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44967 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44968 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44969 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44970 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44971 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44972 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44973 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44974 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44975 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44976 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44977 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44978 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44979 #   undef JITTER_BRANCH_FAST_IF_AND
44980 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
44981 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44982 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
44983 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44984 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44985 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44986 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44987 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44988 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44989 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44990 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44991 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44992 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44993 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44994 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44995 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44996 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44997 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44998 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44999 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45000 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45001 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45002 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45003 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45004 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45005 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45006 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45007 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45008 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45009 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       313
45010 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tysctn
45011 
45012 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tysctn
45013 
45014   /* The residual arity for this instruction does not depend on fast labels. */
45015   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
45016 
45017 
45018 #if defined (JITTER_PROFILE_SAMPLE)
45019   JITTER_PROFILE_SAMPLE_UPDATE
45020      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45021       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45022   /* Force the compiler not move sample-profiling instrumentation
45023      beyond this point; this way the actual user code is timed.
45024      This is still not perfect, as residuals are materialised before
45025      we arrive here, but should be adequate at least for slow VM
45026      instructions. */
45027   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45028 #endif
45029 #if defined (JITTER_PROFILE_COUNT)
45030   /* Notice that, differently from the code above, this
45031      instrumentation code *can* be reordered freely: as long as a
45032      VM instruction is counted, the count increment can be placed
45033      anyehere.  Let GCC move this code and possibly achieve better
45034      throughput by exploiting instruction-level parallelism and
45035      therefore approximate more closely a non-profiled build. */
45036   JITTER_PROFILE_COUNT_UPDATE
45037      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45038       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45039 #endif
45040 
45041 /* User-specified code, instruction-beginning-c part: beginning. */
45042 
45043 /* User-specified code, instruction-beginning-c part: end */
45044 
45045 
45046     /* User code for tysctn . */
45047 #line 5213 "../../libpoke/pvm.jitter"
45048 
45049     pvm_val type = JITTER_TOP_STACK ();
45050     pvm_val type_name = PVM_VAL_TYP_S_NAME (type);
45051 
45052     JITTER_PUSH_STACK (type_name);
45053 
45054     /* End of the user code for tysctn . */
45055 
45056 /* User-specified code, instruction-end-c part: beginning. */
45057 
45058 /* User-specified code, instruction-end-c part: end */
45059 
45060     /* Undefine the tysctn argument macros so they can't be used
45061        by mistake in the instruction body coming next. */
45062 
45063 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45064 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45065 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45066 
45067   }
45068  JITTER_INSTRUCTION_EPILOG_(tysctn, tysctn, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45069 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45070 
45071   JITTER_INSTRUCTION_PROLOG_(unmap, unmap, hot)
45072   {
45073     /* This specialized instruction is not a replacement. */
45074 #   undef JITTER_BRANCH_FAST
45075 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
45076 #   undef JITTER_BRANCH_FAST_IF_ZERO
45077 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
45078 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45079 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
45080 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45081 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
45082 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45083 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
45084 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45085 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
45086 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45087 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
45088 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45089 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
45090 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45091 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
45092 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45093 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
45094 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45095 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45096 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45097 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45098 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45099 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45100 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45101 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45102 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45103 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45104 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45105 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45106 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45107 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45108 #   undef JITTER_BRANCH_FAST_IF_AND
45109 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
45110 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45111 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
45112 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45113 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45114 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45115 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45116 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45117 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45118 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45119 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45120 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45121 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45122 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45123 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45124 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45125 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45126 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45127 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45128 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45129 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45130 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45131 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45132 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45133 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45134 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45135 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45136 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45137 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45138 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       314
45139 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         unmap
45140 
45141 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME unmap
45142 
45143   /* The residual arity for this instruction does not depend on fast labels. */
45144   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
45145 
45146 
45147 #if defined (JITTER_PROFILE_SAMPLE)
45148   JITTER_PROFILE_SAMPLE_UPDATE
45149      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45150       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45151   /* Force the compiler not move sample-profiling instrumentation
45152      beyond this point; this way the actual user code is timed.
45153      This is still not perfect, as residuals are materialised before
45154      we arrive here, but should be adequate at least for slow VM
45155      instructions. */
45156   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45157 #endif
45158 #if defined (JITTER_PROFILE_COUNT)
45159   /* Notice that, differently from the code above, this
45160      instrumentation code *can* be reordered freely: as long as a
45161      VM instruction is counted, the count increment can be placed
45162      anyehere.  Let GCC move this code and possibly achieve better
45163      throughput by exploiting instruction-level parallelism and
45164      therefore approximate more closely a non-profiled build. */
45165   JITTER_PROFILE_COUNT_UPDATE
45166      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45167       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45168 #endif
45169 
45170 /* User-specified code, instruction-beginning-c part: beginning. */
45171 
45172 /* User-specified code, instruction-beginning-c part: end */
45173 
45174 
45175     /* User code for unmap . */
45176 #line 4699 "../../libpoke/pvm.jitter"
45177 
45178     pvm_val_unmap (JITTER_TOP_STACK ());
45179 
45180     /* End of the user code for unmap . */
45181 
45182 /* User-specified code, instruction-end-c part: beginning. */
45183 
45184 /* User-specified code, instruction-end-c part: end */
45185 
45186     /* Undefine the unmap argument macros so they can't be used
45187        by mistake in the instruction body coming next. */
45188 
45189 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45190 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45191 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45192 
45193   }
45194  JITTER_INSTRUCTION_EPILOG_(unmap, unmap, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45195 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45196 
45197   JITTER_INSTRUCTION_PROLOG_(unreachable, unreachable, cold)
45198   {
45199     /* This specialized instruction is not a replacement. */
45200 #   undef JITTER_BRANCH_FAST
45201 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
45202 #   undef JITTER_BRANCH_FAST_IF_ZERO
45203 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
45204 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45205 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
45206 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45207 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
45208 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45209 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
45210 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45211 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
45212 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45213 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
45214 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45215 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
45216 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45217 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
45218 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45219 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
45220 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45221 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45222 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45223 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45224 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45225 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45226 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45227 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45228 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45229 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45230 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45231 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45232 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45233 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45234 #   undef JITTER_BRANCH_FAST_IF_AND
45235 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
45236 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45237 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
45238 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45239 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45240 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45241 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45242 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45243 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45244 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45245 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45246 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45247 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45248 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45249 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45250 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45251 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45252 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45253 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45254 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45255 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45256 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45257 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45258 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45259 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45260 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45261 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45262 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45263 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45264 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       315
45265 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         unreachable
45266 
45267 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME unreachable
45268 
45269   /* The residual arity for this instruction does not depend on fast labels. */
45270   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
45271 
45272 
45273 #if defined (JITTER_PROFILE_SAMPLE)
45274   JITTER_PROFILE_SAMPLE_UPDATE
45275      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45276       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45277   /* Force the compiler not move sample-profiling instrumentation
45278      beyond this point; this way the actual user code is timed.
45279      This is still not perfect, as residuals are materialised before
45280      we arrive here, but should be adequate at least for slow VM
45281      instructions. */
45282   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45283 #endif
45284 #if defined (JITTER_PROFILE_COUNT)
45285   /* Notice that, differently from the code above, this
45286      instrumentation code *can* be reordered freely: as long as a
45287      VM instruction is counted, the count increment can be placed
45288      anyehere.  Let GCC move this code and possibly achieve better
45289      throughput by exploiting instruction-level parallelism and
45290      therefore approximate more closely a non-profiled build. */
45291   JITTER_PROFILE_COUNT_UPDATE
45292      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45293       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45294 #endif
45295 
45296 /* User-specified code, instruction-beginning-c part: beginning. */
45297 
45298 /* User-specified code, instruction-beginning-c part: end */
45299 
45300 
45301     /* User code for unreachable . */
45302 
45303     /* End of the user code for unreachable . */
45304 
45305 /* User-specified code, instruction-end-c part: beginning. */
45306 
45307 /* User-specified code, instruction-end-c part: end */
45308 
45309     /* Undefine the unreachable argument macros so they can't be used
45310        by mistake in the instruction body coming next. */
45311 
45312 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45313 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45314 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45315 
45316   }
45317  JITTER_INSTRUCTION_EPILOG_(unreachable, unreachable, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45318 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45319 
45320   JITTER_INSTRUCTION_PROLOG_(ureloc, ureloc, hot)
45321   {
45322     /* This specialized instruction is not a replacement. */
45323 #   undef JITTER_BRANCH_FAST
45324 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
45325 #   undef JITTER_BRANCH_FAST_IF_ZERO
45326 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
45327 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45328 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
45329 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45330 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
45331 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45332 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
45333 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45334 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
45335 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45336 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
45337 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45338 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
45339 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45340 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
45341 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45342 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
45343 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45344 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45345 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45346 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45347 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45348 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45349 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45350 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45351 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45352 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45353 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45354 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45355 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45356 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45357 #   undef JITTER_BRANCH_FAST_IF_AND
45358 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
45359 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45360 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
45361 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45362 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45363 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45364 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45365 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45366 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45367 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45368 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45369 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45370 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45371 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45372 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45373 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45374 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45375 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45376 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45377 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45378 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45379 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45380 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45381 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45382 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45383 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45384 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45385 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45386 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45387 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       316
45388 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         ureloc
45389 
45390 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME ureloc
45391 
45392   /* The residual arity for this instruction does not depend on fast labels. */
45393   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
45394 
45395 
45396 #if defined (JITTER_PROFILE_SAMPLE)
45397   JITTER_PROFILE_SAMPLE_UPDATE
45398      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45399       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45400   /* Force the compiler not move sample-profiling instrumentation
45401      beyond this point; this way the actual user code is timed.
45402      This is still not perfect, as residuals are materialised before
45403      we arrive here, but should be adequate at least for slow VM
45404      instructions. */
45405   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45406 #endif
45407 #if defined (JITTER_PROFILE_COUNT)
45408   /* Notice that, differently from the code above, this
45409      instrumentation code *can* be reordered freely: as long as a
45410      VM instruction is counted, the count increment can be placed
45411      anyehere.  Let GCC move this code and possibly achieve better
45412      throughput by exploiting instruction-level parallelism and
45413      therefore approximate more closely a non-profiled build. */
45414   JITTER_PROFILE_COUNT_UPDATE
45415      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45416       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45417 #endif
45418 
45419 /* User-specified code, instruction-beginning-c part: beginning. */
45420 
45421 /* User-specified code, instruction-beginning-c part: end */
45422 
45423 
45424     /* User code for ureloc . */
45425 #line 4742 "../../libpoke/pvm.jitter"
45426 
45427       pvm_val val = JITTER_TOP_STACK ();
45428 
45429       if (!(PVM_IS_ARR (val) || PVM_IS_SCT (val)))
45430         PVM_RAISE_DFL (PVM_E_INVAL);
45431 
45432       pvm_val_ureloc (val);
45433 
45434     /* End of the user code for ureloc . */
45435 
45436 /* User-specified code, instruction-end-c part: beginning. */
45437 
45438 /* User-specified code, instruction-end-c part: end */
45439 
45440     /* Undefine the ureloc argument macros so they can't be used
45441        by mistake in the instruction body coming next. */
45442 
45443 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45444 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45445 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45446 
45447   }
45448  JITTER_INSTRUCTION_EPILOG_(ureloc, ureloc, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45449 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45450 
45451   JITTER_INSTRUCTION_PROLOG_(write/retR, write__retR, hot)
45452   {
45453     /* This specialized instruction is not a replacement. */
45454 #   undef JITTER_BRANCH_FAST
45455 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
45456 #   undef JITTER_BRANCH_FAST_IF_ZERO
45457 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
45458 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45459 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
45460 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45461 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
45462 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45463 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
45464 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45465 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
45466 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45467 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
45468 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45469 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
45470 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45471 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
45472 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45473 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
45474 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45475 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45476 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45477 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45478 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45479 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45480 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45481 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45482 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45483 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45484 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45485 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45486 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45487 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45488 #   undef JITTER_BRANCH_FAST_IF_AND
45489 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
45490 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45491 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
45492 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45493 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45494 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45495 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45496 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45497 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45498 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45499 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45500 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45501 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45502 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45503 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45504 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45505 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45506 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45507 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45508 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45509 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45510 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45511 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45512 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45513 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45514 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45515 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45516 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45517 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45518     /* This specialized instruction is a caller.
45519        Its 0-th argument, a literal, is the return address where to jump
45520        back after the procedure returns.  Branch-and-link
45521        functionality is enabled for this instruction. */
45522 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
45523 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45524 
45525 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       317
45526 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         write/retR
45527 
45528 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME write__retR
45529 
45530   /* The residual arity for this instruction does not depend on fast labels. */
45531   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
45532 
45533     /* The 0th argument is a residual literal. */
45534 #if defined(JITTER_DISPATCH_NO_THREADING)
45535 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
45536     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45537 #elif defined (JITTER_REPLICATE)
45538 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
45539 #else
45540 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
45541 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45542 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45543 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45544 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45545 #   define JITTER_ARGF0 JITTER_ARGP0
45546 
45547 
45548 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
45549     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
45550   /* We use the implicit atgument at the end of the calling.
45551      instruction to discover the procedure return address. */
45552   const void * _jitter_return_pointer = JITTER_ARGP0;
45553   /* And make it accessible to the user (who will usually call
45554      JITTER_BRANCH_AND_LINK) thru a nice macro. */
45555 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
45556 #endif
45557 
45558 #if defined (JITTER_PROFILE_SAMPLE)
45559   JITTER_PROFILE_SAMPLE_UPDATE
45560      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45561       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45562   /* Force the compiler not move sample-profiling instrumentation
45563      beyond this point; this way the actual user code is timed.
45564      This is still not perfect, as residuals are materialised before
45565      we arrive here, but should be adequate at least for slow VM
45566      instructions. */
45567   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45568 #endif
45569 #if defined (JITTER_PROFILE_COUNT)
45570   /* Notice that, differently from the code above, this
45571      instrumentation code *can* be reordered freely: as long as a
45572      VM instruction is counted, the count increment can be placed
45573      anyehere.  Let GCC move this code and possibly achieve better
45574      throughput by exploiting instruction-level parallelism and
45575      therefore approximate more closely a non-profiled build. */
45576   JITTER_PROFILE_COUNT_UPDATE
45577      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45578       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45579 #endif
45580 
45581 /* User-specified code, instruction-beginning-c part: beginning. */
45582 
45583 /* User-specified code, instruction-beginning-c part: end */
45584 
45585 
45586     /* User code for write/retR . */
45587 #line 5234 "../../libpoke/pvm.jitter"
45588 
45589      pvm_val val = JITTER_TOP_STACK ();
45590      pvm_val writer = pvm_val_writer (val);
45591 
45592      if (writer != PVM_NULL)
45593      {
45594         JITTER_DUP_STACK ();                      /* VAL VAL */
45595         JITTER_PUSH_STACK (PVM_VAL_OFFSET (val)); /* VAL VAL OFF */
45596         PVM_CALL (writer);
45597       }
45598 
45599     /* End of the user code for write/retR . */
45600 
45601 /* User-specified code, instruction-end-c part: beginning. */
45602 
45603 /* User-specified code, instruction-end-c part: end */
45604 
45605     /* Undefine macros only visible in caller instructions. */
45606 #   undef JITTER_BRANCH_AND_LINK
45607 #   undef JITTER_BRANCH_FAST_AND_LINK
45608 
45609     /* Undefine the write/retR argument macros so they can't be used
45610        by mistake in the instruction body coming next. */
45611 #   undef JITTER_SLOW_REGISTER_OFFSET0
45612 #   undef JITTER_ARG0
45613 #   undef JITTER_ARGN0
45614 #   undef JITTER_ARGU0
45615 #   undef JITTER_ARGP0
45616 #   undef JITTER_ARGF0
45617 
45618 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45619 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45620 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45621 
45622   }
45623 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
45624     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
45625 # undef JITTER_RETURN_ADDRESS
45626 #endif
45627 
45628  JITTER_INSTRUCTION_EPILOG_(write/retR, write__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45629 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45630 
45631   JITTER_INSTRUCTION_PROLOG_(*ba/fR*-no-fast-branches, _Aba__fR_A_mno_mfast_mbranches, hot)
45632   {
45633     /* This specialized instruction is a replacement. */
45634 #   undef JITTER_BRANCH_FAST
45635 #   define JITTER_BRANCH_FAST JITTER_BRANCH
45636 #   undef JITTER_BRANCH_FAST_IF_ZERO
45637 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
45638 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45639 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
45640 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45641 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
45642 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45643 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
45644 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45645 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
45646 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45647 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
45648 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45649 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
45650 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45651 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
45652 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45653 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
45654 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45655 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
45656 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45657 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
45658 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45659 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
45660 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45661 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
45662 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45663 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
45664 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45665 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
45666 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45667 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
45668 #   undef JITTER_BRANCH_FAST_IF_AND
45669 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
45670 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45671 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
45672 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45673 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
45674 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45675 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
45676 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45677 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
45678 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45679 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
45680 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45681 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
45682 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45683 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
45684 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45685 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
45686 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45687 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
45688 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45689 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
45690 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45691 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
45692 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45693 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
45694 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45695 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
45696 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45697 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
45698     /* This specialized instruction is non-relocatable.
45699        Its 0-th argument, a literal, is the return address where to jump
45700        at the end, back to relocated code. */
45701 
45702 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       318
45703 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *ba/fR*-no-fast-branches
45704 
45705 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aba__fR_A_mno_mfast_mbranches
45706 
45707   /* The residual arity for this instruction does not depend on fast labels. */
45708   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
45709 
45710   /* Define argument-access macros for *ba/fR*-no-fast-branches . */
45711 #ifdef JITTER_HAVE_PATCH_IN
45712   /* Define argument-access macros assuming that fast branches are enabled. */
45713     /* The 0th argument is a residual label. */
45714 #if defined(JITTER_DISPATCH_NO_THREADING)
45715 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
45716     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45717 #elif defined (JITTER_REPLICATE)
45718 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
45719 #else
45720 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
45721 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45722 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45723 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45724 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45725 #   define JITTER_ARGF0 JITTER_ARGP0
45726 
45727 #else
45728   /* Define argument-access macros assuming that fast branches are disabled. */
45729     /* The 0th argument is a residual label. */
45730 #if defined(JITTER_DISPATCH_NO_THREADING)
45731 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
45732     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45733 #elif defined (JITTER_REPLICATE)
45734 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
45735 #else
45736 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
45737 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45738 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45739 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45740 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45741 #   define JITTER_ARGF0 JITTER_ARGP0
45742 
45743 # endif // #ifdef JITTER_HAVE_PATCH_IN
45744 
45745 #ifdef JITTER_REPLICATE
45746     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
45747        it on the stack rather than in read-only memory.  I had to do this to prevent
45748        a GCC 8 snapshot on SH from being too clever. */
45749     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45750     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
45751        in memory, as a 16-bit constant; and since it reads it with a PC-relative
45752        load the relocated part crashes.
45753                  mov.w     .L1667,r0
45754                  mov.l     @(r0,r15),r1
45755                  jmp       @r1
45756        r15 is the stack pointer.  The constant at .L1667 is
45757           .L1667:
45758                  .short    232
45759        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
45760        can't work as an immediate.  Shall I keep these code pointers as a single array?
45761        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
45762        but the problem will be the same. */
45763     /* Jump to non-relocatable code. */
45764     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45765 
45766     /* Here the residual arity is given as zero: it's too late to
45767        skip residuals, since we've already jumped and this code is
45768        unreachable.  The instruction pointer, if any, is advanced
45769        in the non-relocatable code. */
45770     JITTER_INSTRUCTION_EPILOG_(*ba/fR*-no-fast-branches, _Aba__fR_A_mno_mfast_mbranches, 0)
45771 
45772     /* Relocated code will jump to this label in non-relocated code. */
45773   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
45774     JITTER_COMMENT_IN_ASM_("*ba/fR*-no-fast-branches non-relocatable code");
45775 #endif // #ifdef JITTER_REPLICATE
45776 #if defined (JITTER_PROFILE_SAMPLE)
45777   JITTER_PROFILE_SAMPLE_UPDATE
45778      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45779       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45780   /* Force the compiler not move sample-profiling instrumentation
45781      beyond this point; this way the actual user code is timed.
45782      This is still not perfect, as residuals are materialised before
45783      we arrive here, but should be adequate at least for slow VM
45784      instructions. */
45785   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45786 #endif
45787 #if defined (JITTER_PROFILE_COUNT)
45788   /* Notice that, differently from the code above, this
45789      instrumentation code *can* be reordered freely: as long as a
45790      VM instruction is counted, the count increment can be placed
45791      anyehere.  Let GCC move this code and possibly achieve better
45792      throughput by exploiting instruction-level parallelism and
45793      therefore approximate more closely a non-profiled build. */
45794   JITTER_PROFILE_COUNT_UPDATE
45795      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45796       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45797 #endif
45798 
45799 /* User-specified code, instruction-beginning-c part: beginning. */
45800 
45801 /* User-specified code, instruction-beginning-c part: end */
45802 
45803 
45804     /* User code for *ba/fR*-no-fast-branches . */
45805 #line 3589 "../../libpoke/pvm.jitter"
45806 
45807     JITTER_BRANCH_FAST(JITTER_ARGF0);
45808 
45809     /* End of the user code for *ba/fR*-no-fast-branches . */
45810 
45811 /* User-specified code, instruction-end-c part: beginning. */
45812 
45813 /* User-specified code, instruction-end-c part: end */
45814 
45815 #ifdef JITTER_REPLICATE
45816     /* Advance the instruction pointer, if any, to skip residuals;
45817        then jump back to replicated code. */
45818     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
45819     JITTER_SKIP_RESIDUALS_;
45820     goto * _jitter_back_to_replicated_code_pointer;
45821 #endif // #ifdef JITTER_REPLICATE
45822 
45823     /* Undefine the *ba/fR*-no-fast-branches argument macros so they can't be used
45824        by mistake in the instruction body coming next. */
45825 #   undef JITTER_SLOW_REGISTER_OFFSET0
45826 #   undef JITTER_ARG0
45827 #   undef JITTER_ARGN0
45828 #   undef JITTER_ARGU0
45829 #   undef JITTER_ARGP0
45830 #   undef JITTER_ARGF0
45831 
45832 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45833 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45834 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45835 
45836   }
45837 #ifndef JITTER_REPLICATE
45838  JITTER_INSTRUCTION_EPILOG_(*ba/fR*-no-fast-branches, _Aba__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45839 #endif // #ifndef JITTER_REPLICATE
45840 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45841 
45842   JITTER_INSTRUCTION_PROLOG_(*bn/fR*-no-fast-branches, _Abn__fR_A_mno_mfast_mbranches, hot)
45843   {
45844     /* This specialized instruction is a replacement. */
45845 #   undef JITTER_BRANCH_FAST
45846 #   define JITTER_BRANCH_FAST JITTER_BRANCH
45847 #   undef JITTER_BRANCH_FAST_IF_ZERO
45848 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
45849 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45850 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
45851 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45852 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
45853 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45854 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
45855 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45856 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
45857 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45858 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
45859 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45860 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
45861 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45862 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
45863 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45864 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
45865 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45866 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
45867 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45868 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
45869 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45870 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
45871 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45872 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
45873 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45874 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
45875 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45876 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
45877 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45878 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
45879 #   undef JITTER_BRANCH_FAST_IF_AND
45880 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
45881 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45882 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
45883 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45884 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
45885 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45886 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
45887 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45888 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
45889 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45890 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
45891 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45892 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
45893 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45894 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
45895 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45896 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
45897 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45898 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
45899 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45900 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
45901 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45902 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
45903 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45904 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
45905 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45906 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
45907 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45908 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
45909     /* This specialized instruction is non-relocatable.
45910        Its 0-th argument, a literal, is the return address where to jump
45911        at the end, back to relocated code. */
45912 
45913 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       319
45914 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bn/fR*-no-fast-branches
45915 
45916 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abn__fR_A_mno_mfast_mbranches
45917 
45918   /* The residual arity for this instruction does not depend on fast labels. */
45919   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
45920 
45921   /* Define argument-access macros for *bn/fR*-no-fast-branches . */
45922 #ifdef JITTER_HAVE_PATCH_IN
45923   /* Define argument-access macros assuming that fast branches are enabled. */
45924     /* The 0th argument is a residual label. */
45925 #if defined(JITTER_DISPATCH_NO_THREADING)
45926 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
45927     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45928 #elif defined (JITTER_REPLICATE)
45929 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
45930 #else
45931 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
45932 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45933 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45934 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45935 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45936 #   define JITTER_ARGF0 JITTER_ARGP0
45937 
45938 #else
45939   /* Define argument-access macros assuming that fast branches are disabled. */
45940     /* The 0th argument is a residual label. */
45941 #if defined(JITTER_DISPATCH_NO_THREADING)
45942 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
45943     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45944 #elif defined (JITTER_REPLICATE)
45945 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
45946 #else
45947 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
45948 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45949 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45950 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45951 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45952 #   define JITTER_ARGF0 JITTER_ARGP0
45953 
45954 # endif // #ifdef JITTER_HAVE_PATCH_IN
45955 
45956 #ifdef JITTER_REPLICATE
45957     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
45958        it on the stack rather than in read-only memory.  I had to do this to prevent
45959        a GCC 8 snapshot on SH from being too clever. */
45960     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45961     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
45962        in memory, as a 16-bit constant; and since it reads it with a PC-relative
45963        load the relocated part crashes.
45964                  mov.w     .L1667,r0
45965                  mov.l     @(r0,r15),r1
45966                  jmp       @r1
45967        r15 is the stack pointer.  The constant at .L1667 is
45968           .L1667:
45969                  .short    232
45970        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
45971        can't work as an immediate.  Shall I keep these code pointers as a single array?
45972        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
45973        but the problem will be the same. */
45974     /* Jump to non-relocatable code. */
45975     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45976 
45977     /* Here the residual arity is given as zero: it's too late to
45978        skip residuals, since we've already jumped and this code is
45979        unreachable.  The instruction pointer, if any, is advanced
45980        in the non-relocatable code. */
45981     JITTER_INSTRUCTION_EPILOG_(*bn/fR*-no-fast-branches, _Abn__fR_A_mno_mfast_mbranches, 0)
45982 
45983     /* Relocated code will jump to this label in non-relocated code. */
45984   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
45985     JITTER_COMMENT_IN_ASM_("*bn/fR*-no-fast-branches non-relocatable code");
45986 #endif // #ifdef JITTER_REPLICATE
45987 #if defined (JITTER_PROFILE_SAMPLE)
45988   JITTER_PROFILE_SAMPLE_UPDATE
45989      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45990       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45991   /* Force the compiler not move sample-profiling instrumentation
45992      beyond this point; this way the actual user code is timed.
45993      This is still not perfect, as residuals are materialised before
45994      we arrive here, but should be adequate at least for slow VM
45995      instructions. */
45996   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45997 #endif
45998 #if defined (JITTER_PROFILE_COUNT)
45999   /* Notice that, differently from the code above, this
46000      instrumentation code *can* be reordered freely: as long as a
46001      VM instruction is counted, the count increment can be placed
46002      anyehere.  Let GCC move this code and possibly achieve better
46003      throughput by exploiting instruction-level parallelism and
46004      therefore approximate more closely a non-profiled build. */
46005   JITTER_PROFILE_COUNT_UPDATE
46006      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46007       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46008 #endif
46009 
46010 /* User-specified code, instruction-beginning-c part: beginning. */
46011 
46012 /* User-specified code, instruction-beginning-c part: end */
46013 
46014 
46015     /* User code for *bn/fR*-no-fast-branches . */
46016 #line 3602 "../../libpoke/pvm.jitter"
46017 
46018     pvm_val tmp = JITTER_TOP_STACK ();
46019     JITTER_BRANCH_FAST_IF_ZERO (tmp != PVM_NULL, JITTER_ARGF0);
46020 
46021     /* End of the user code for *bn/fR*-no-fast-branches . */
46022 
46023 /* User-specified code, instruction-end-c part: beginning. */
46024 
46025 /* User-specified code, instruction-end-c part: end */
46026 
46027 #ifdef JITTER_REPLICATE
46028     /* Advance the instruction pointer, if any, to skip residuals;
46029        then jump back to replicated code. */
46030     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
46031     JITTER_SKIP_RESIDUALS_;
46032     goto * _jitter_back_to_replicated_code_pointer;
46033 #endif // #ifdef JITTER_REPLICATE
46034 
46035     /* Undefine the *bn/fR*-no-fast-branches argument macros so they can't be used
46036        by mistake in the instruction body coming next. */
46037 #   undef JITTER_SLOW_REGISTER_OFFSET0
46038 #   undef JITTER_ARG0
46039 #   undef JITTER_ARGN0
46040 #   undef JITTER_ARGU0
46041 #   undef JITTER_ARGP0
46042 #   undef JITTER_ARGF0
46043 
46044 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46045 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46046 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46047 
46048   }
46049 #ifndef JITTER_REPLICATE
46050  JITTER_INSTRUCTION_EPILOG_(*bn/fR*-no-fast-branches, _Abn__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46051 #endif // #ifndef JITTER_REPLICATE
46052 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46053 
46054   JITTER_INSTRUCTION_PROLOG_(*bnn/fR*-no-fast-branches, _Abnn__fR_A_mno_mfast_mbranches, hot)
46055   {
46056     /* This specialized instruction is a replacement. */
46057 #   undef JITTER_BRANCH_FAST
46058 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46059 #   undef JITTER_BRANCH_FAST_IF_ZERO
46060 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46061 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46062 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46063 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46064 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46065 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46066 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46067 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46068 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46069 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46070 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46071 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46072 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46073 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46074 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46075 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46076 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46077 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46078 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46079 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46080 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46081 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46082 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46083 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46084 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46085 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46086 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46087 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46088 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46089 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46090 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46091 #   undef JITTER_BRANCH_FAST_IF_AND
46092 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46093 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46094 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46095 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46096 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46097 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46098 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46099 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46100 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46101 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46102 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46103 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46104 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46105 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46106 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46107 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46108 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46109 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46110 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46111 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46112 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46113 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46114 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46115 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46116 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46117 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46118 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46119 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46120 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46121     /* This specialized instruction is non-relocatable.
46122        Its 0-th argument, a literal, is the return address where to jump
46123        at the end, back to relocated code. */
46124 
46125 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       320
46126 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bnn/fR*-no-fast-branches
46127 
46128 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abnn__fR_A_mno_mfast_mbranches
46129 
46130   /* The residual arity for this instruction does not depend on fast labels. */
46131   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46132 
46133   /* Define argument-access macros for *bnn/fR*-no-fast-branches . */
46134 #ifdef JITTER_HAVE_PATCH_IN
46135   /* Define argument-access macros assuming that fast branches are enabled. */
46136     /* The 0th argument is a residual label. */
46137 #if defined(JITTER_DISPATCH_NO_THREADING)
46138 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46139     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46140 #elif defined (JITTER_REPLICATE)
46141 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46142 #else
46143 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46144 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46145 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46146 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46147 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46148 #   define JITTER_ARGF0 JITTER_ARGP0
46149 
46150 #else
46151   /* Define argument-access macros assuming that fast branches are disabled. */
46152     /* The 0th argument is a residual label. */
46153 #if defined(JITTER_DISPATCH_NO_THREADING)
46154 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46155     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46156 #elif defined (JITTER_REPLICATE)
46157 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46158 #else
46159 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46160 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46161 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46162 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46163 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46164 #   define JITTER_ARGF0 JITTER_ARGP0
46165 
46166 # endif // #ifdef JITTER_HAVE_PATCH_IN
46167 
46168 #ifdef JITTER_REPLICATE
46169     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46170        it on the stack rather than in read-only memory.  I had to do this to prevent
46171        a GCC 8 snapshot on SH from being too clever. */
46172     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46173     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46174        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46175        load the relocated part crashes.
46176                  mov.w     .L1667,r0
46177                  mov.l     @(r0,r15),r1
46178                  jmp       @r1
46179        r15 is the stack pointer.  The constant at .L1667 is
46180           .L1667:
46181                  .short    232
46182        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46183        can't work as an immediate.  Shall I keep these code pointers as a single array?
46184        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46185        but the problem will be the same. */
46186     /* Jump to non-relocatable code. */
46187     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46188 
46189     /* Here the residual arity is given as zero: it's too late to
46190        skip residuals, since we've already jumped and this code is
46191        unreachable.  The instruction pointer, if any, is advanced
46192        in the non-relocatable code. */
46193     JITTER_INSTRUCTION_EPILOG_(*bnn/fR*-no-fast-branches, _Abnn__fR_A_mno_mfast_mbranches, 0)
46194 
46195     /* Relocated code will jump to this label in non-relocated code. */
46196   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46197     JITTER_COMMENT_IN_ASM_("*bnn/fR*-no-fast-branches non-relocatable code");
46198 #endif // #ifdef JITTER_REPLICATE
46199 #if defined (JITTER_PROFILE_SAMPLE)
46200   JITTER_PROFILE_SAMPLE_UPDATE
46201      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46202       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46203   /* Force the compiler not move sample-profiling instrumentation
46204      beyond this point; this way the actual user code is timed.
46205      This is still not perfect, as residuals are materialised before
46206      we arrive here, but should be adequate at least for slow VM
46207      instructions. */
46208   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46209 #endif
46210 #if defined (JITTER_PROFILE_COUNT)
46211   /* Notice that, differently from the code above, this
46212      instrumentation code *can* be reordered freely: as long as a
46213      VM instruction is counted, the count increment can be placed
46214      anyehere.  Let GCC move this code and possibly achieve better
46215      throughput by exploiting instruction-level parallelism and
46216      therefore approximate more closely a non-profiled build. */
46217   JITTER_PROFILE_COUNT_UPDATE
46218      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46219       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46220 #endif
46221 
46222 /* User-specified code, instruction-beginning-c part: beginning. */
46223 
46224 /* User-specified code, instruction-beginning-c part: end */
46225 
46226 
46227     /* User code for *bnn/fR*-no-fast-branches . */
46228 #line 3616 "../../libpoke/pvm.jitter"
46229 
46230     pvm_val tmp = JITTER_TOP_STACK ();
46231     JITTER_BRANCH_FAST_IF_ZERO (tmp == PVM_NULL, JITTER_ARGF0);
46232 
46233     /* End of the user code for *bnn/fR*-no-fast-branches . */
46234 
46235 /* User-specified code, instruction-end-c part: beginning. */
46236 
46237 /* User-specified code, instruction-end-c part: end */
46238 
46239 #ifdef JITTER_REPLICATE
46240     /* Advance the instruction pointer, if any, to skip residuals;
46241        then jump back to replicated code. */
46242     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
46243     JITTER_SKIP_RESIDUALS_;
46244     goto * _jitter_back_to_replicated_code_pointer;
46245 #endif // #ifdef JITTER_REPLICATE
46246 
46247     /* Undefine the *bnn/fR*-no-fast-branches argument macros so they can't be used
46248        by mistake in the instruction body coming next. */
46249 #   undef JITTER_SLOW_REGISTER_OFFSET0
46250 #   undef JITTER_ARG0
46251 #   undef JITTER_ARGN0
46252 #   undef JITTER_ARGU0
46253 #   undef JITTER_ARGP0
46254 #   undef JITTER_ARGF0
46255 
46256 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46257 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46258 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46259 
46260   }
46261 #ifndef JITTER_REPLICATE
46262  JITTER_INSTRUCTION_EPILOG_(*bnn/fR*-no-fast-branches, _Abnn__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46263 #endif // #ifndef JITTER_REPLICATE
46264 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46265 
46266   JITTER_INSTRUCTION_PROLOG_(*bnzi/fR*-no-fast-branches, _Abnzi__fR_A_mno_mfast_mbranches, hot)
46267   {
46268     /* This specialized instruction is a replacement. */
46269 #   undef JITTER_BRANCH_FAST
46270 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46271 #   undef JITTER_BRANCH_FAST_IF_ZERO
46272 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46273 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46274 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46275 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46276 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46277 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46278 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46279 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46280 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46281 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46282 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46283 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46284 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46285 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46286 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46287 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46288 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46289 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46290 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46291 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46292 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46293 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46294 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46295 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46296 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46297 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46298 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46299 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46300 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46301 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46302 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46303 #   undef JITTER_BRANCH_FAST_IF_AND
46304 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46305 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46306 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46307 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46308 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46309 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46310 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46311 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46312 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46313 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46314 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46315 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46316 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46317 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46318 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46319 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46320 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46321 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46322 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46323 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46324 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46325 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46326 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46327 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46328 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46329 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46330 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46331 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46332 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46333     /* This specialized instruction is non-relocatable.
46334        Its 0-th argument, a literal, is the return address where to jump
46335        at the end, back to relocated code. */
46336 
46337 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       321
46338 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bnzi/fR*-no-fast-branches
46339 
46340 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abnzi__fR_A_mno_mfast_mbranches
46341 
46342   /* The residual arity for this instruction does not depend on fast labels. */
46343   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46344 
46345   /* Define argument-access macros for *bnzi/fR*-no-fast-branches . */
46346 #ifdef JITTER_HAVE_PATCH_IN
46347   /* Define argument-access macros assuming that fast branches are enabled. */
46348     /* The 0th argument is a residual label. */
46349 #if defined(JITTER_DISPATCH_NO_THREADING)
46350 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46351     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46352 #elif defined (JITTER_REPLICATE)
46353 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46354 #else
46355 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46356 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46357 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46358 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46359 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46360 #   define JITTER_ARGF0 JITTER_ARGP0
46361 
46362 #else
46363   /* Define argument-access macros assuming that fast branches are disabled. */
46364     /* The 0th argument is a residual label. */
46365 #if defined(JITTER_DISPATCH_NO_THREADING)
46366 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46367     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46368 #elif defined (JITTER_REPLICATE)
46369 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46370 #else
46371 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46372 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46373 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46374 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46375 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46376 #   define JITTER_ARGF0 JITTER_ARGP0
46377 
46378 # endif // #ifdef JITTER_HAVE_PATCH_IN
46379 
46380 #ifdef JITTER_REPLICATE
46381     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46382        it on the stack rather than in read-only memory.  I had to do this to prevent
46383        a GCC 8 snapshot on SH from being too clever. */
46384     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46385     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46386        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46387        load the relocated part crashes.
46388                  mov.w     .L1667,r0
46389                  mov.l     @(r0,r15),r1
46390                  jmp       @r1
46391        r15 is the stack pointer.  The constant at .L1667 is
46392           .L1667:
46393                  .short    232
46394        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46395        can't work as an immediate.  Shall I keep these code pointers as a single array?
46396        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46397        but the problem will be the same. */
46398     /* Jump to non-relocatable code. */
46399     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46400 
46401     /* Here the residual arity is given as zero: it's too late to
46402        skip residuals, since we've already jumped and this code is
46403        unreachable.  The instruction pointer, if any, is advanced
46404        in the non-relocatable code. */
46405     JITTER_INSTRUCTION_EPILOG_(*bnzi/fR*-no-fast-branches, _Abnzi__fR_A_mno_mfast_mbranches, 0)
46406 
46407     /* Relocated code will jump to this label in non-relocated code. */
46408   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46409     JITTER_COMMENT_IN_ASM_("*bnzi/fR*-no-fast-branches non-relocatable code");
46410 #endif // #ifdef JITTER_REPLICATE
46411 #if defined (JITTER_PROFILE_SAMPLE)
46412   JITTER_PROFILE_SAMPLE_UPDATE
46413      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46414       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46415   /* Force the compiler not move sample-profiling instrumentation
46416      beyond this point; this way the actual user code is timed.
46417      This is still not perfect, as residuals are materialised before
46418      we arrive here, but should be adequate at least for slow VM
46419      instructions. */
46420   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46421 #endif
46422 #if defined (JITTER_PROFILE_COUNT)
46423   /* Notice that, differently from the code above, this
46424      instrumentation code *can* be reordered freely: as long as a
46425      VM instruction is counted, the count increment can be placed
46426      anyehere.  Let GCC move this code and possibly achieve better
46427      throughput by exploiting instruction-level parallelism and
46428      therefore approximate more closely a non-profiled build. */
46429   JITTER_PROFILE_COUNT_UPDATE
46430      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46431       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46432 #endif
46433 
46434 /* User-specified code, instruction-beginning-c part: beginning. */
46435 
46436 /* User-specified code, instruction-beginning-c part: end */
46437 
46438 
46439     /* User code for *bnzi/fR*-no-fast-branches . */
46440 #line 3686 "../../libpoke/pvm.jitter"
46441 
46442     pvm_val tmp = JITTER_TOP_STACK ();
46443     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_INT (tmp), JITTER_ARGF0);
46444 
46445     /* End of the user code for *bnzi/fR*-no-fast-branches . */
46446 
46447 /* User-specified code, instruction-end-c part: beginning. */
46448 
46449 /* User-specified code, instruction-end-c part: end */
46450 
46451 #ifdef JITTER_REPLICATE
46452     /* Advance the instruction pointer, if any, to skip residuals;
46453        then jump back to replicated code. */
46454     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
46455     JITTER_SKIP_RESIDUALS_;
46456     goto * _jitter_back_to_replicated_code_pointer;
46457 #endif // #ifdef JITTER_REPLICATE
46458 
46459     /* Undefine the *bnzi/fR*-no-fast-branches argument macros so they can't be used
46460        by mistake in the instruction body coming next. */
46461 #   undef JITTER_SLOW_REGISTER_OFFSET0
46462 #   undef JITTER_ARG0
46463 #   undef JITTER_ARGN0
46464 #   undef JITTER_ARGU0
46465 #   undef JITTER_ARGP0
46466 #   undef JITTER_ARGF0
46467 
46468 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46469 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46470 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46471 
46472   }
46473 #ifndef JITTER_REPLICATE
46474  JITTER_INSTRUCTION_EPILOG_(*bnzi/fR*-no-fast-branches, _Abnzi__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46475 #endif // #ifndef JITTER_REPLICATE
46476 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46477 
46478   JITTER_INSTRUCTION_PROLOG_(*bnziu/fR*-no-fast-branches, _Abnziu__fR_A_mno_mfast_mbranches, hot)
46479   {
46480     /* This specialized instruction is a replacement. */
46481 #   undef JITTER_BRANCH_FAST
46482 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46483 #   undef JITTER_BRANCH_FAST_IF_ZERO
46484 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46485 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46486 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46487 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46488 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46489 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46490 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46491 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46492 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46493 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46494 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46495 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46496 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46497 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46498 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46499 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46500 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46501 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46502 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46503 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46504 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46505 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46506 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46507 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46508 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46509 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46510 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46511 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46512 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46513 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46514 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46515 #   undef JITTER_BRANCH_FAST_IF_AND
46516 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46517 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46518 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46519 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46520 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46521 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46522 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46523 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46524 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46525 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46526 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46527 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46528 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46529 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46530 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46531 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46532 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46533 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46534 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46535 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46536 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46537 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46538 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46539 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46540 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46541 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46542 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46543 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46544 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46545     /* This specialized instruction is non-relocatable.
46546        Its 0-th argument, a literal, is the return address where to jump
46547        at the end, back to relocated code. */
46548 
46549 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       322
46550 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bnziu/fR*-no-fast-branches
46551 
46552 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abnziu__fR_A_mno_mfast_mbranches
46553 
46554   /* The residual arity for this instruction does not depend on fast labels. */
46555   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46556 
46557   /* Define argument-access macros for *bnziu/fR*-no-fast-branches . */
46558 #ifdef JITTER_HAVE_PATCH_IN
46559   /* Define argument-access macros assuming that fast branches are enabled. */
46560     /* The 0th argument is a residual label. */
46561 #if defined(JITTER_DISPATCH_NO_THREADING)
46562 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46563     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46564 #elif defined (JITTER_REPLICATE)
46565 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46566 #else
46567 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46568 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46569 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46570 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46571 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46572 #   define JITTER_ARGF0 JITTER_ARGP0
46573 
46574 #else
46575   /* Define argument-access macros assuming that fast branches are disabled. */
46576     /* The 0th argument is a residual label. */
46577 #if defined(JITTER_DISPATCH_NO_THREADING)
46578 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46579     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46580 #elif defined (JITTER_REPLICATE)
46581 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46582 #else
46583 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46584 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46585 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46586 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46587 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46588 #   define JITTER_ARGF0 JITTER_ARGP0
46589 
46590 # endif // #ifdef JITTER_HAVE_PATCH_IN
46591 
46592 #ifdef JITTER_REPLICATE
46593     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46594        it on the stack rather than in read-only memory.  I had to do this to prevent
46595        a GCC 8 snapshot on SH from being too clever. */
46596     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46597     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46598        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46599        load the relocated part crashes.
46600                  mov.w     .L1667,r0
46601                  mov.l     @(r0,r15),r1
46602                  jmp       @r1
46603        r15 is the stack pointer.  The constant at .L1667 is
46604           .L1667:
46605                  .short    232
46606        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46607        can't work as an immediate.  Shall I keep these code pointers as a single array?
46608        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46609        but the problem will be the same. */
46610     /* Jump to non-relocatable code. */
46611     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46612 
46613     /* Here the residual arity is given as zero: it's too late to
46614        skip residuals, since we've already jumped and this code is
46615        unreachable.  The instruction pointer, if any, is advanced
46616        in the non-relocatable code. */
46617     JITTER_INSTRUCTION_EPILOG_(*bnziu/fR*-no-fast-branches, _Abnziu__fR_A_mno_mfast_mbranches, 0)
46618 
46619     /* Relocated code will jump to this label in non-relocated code. */
46620   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46621     JITTER_COMMENT_IN_ASM_("*bnziu/fR*-no-fast-branches non-relocatable code");
46622 #endif // #ifdef JITTER_REPLICATE
46623 #if defined (JITTER_PROFILE_SAMPLE)
46624   JITTER_PROFILE_SAMPLE_UPDATE
46625      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46626       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46627   /* Force the compiler not move sample-profiling instrumentation
46628      beyond this point; this way the actual user code is timed.
46629      This is still not perfect, as residuals are materialised before
46630      we arrive here, but should be adequate at least for slow VM
46631      instructions. */
46632   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46633 #endif
46634 #if defined (JITTER_PROFILE_COUNT)
46635   /* Notice that, differently from the code above, this
46636      instrumentation code *can* be reordered freely: as long as a
46637      VM instruction is counted, the count increment can be placed
46638      anyehere.  Let GCC move this code and possibly achieve better
46639      throughput by exploiting instruction-level parallelism and
46640      therefore approximate more closely a non-profiled build. */
46641   JITTER_PROFILE_COUNT_UPDATE
46642      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46643       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46644 #endif
46645 
46646 /* User-specified code, instruction-beginning-c part: beginning. */
46647 
46648 /* User-specified code, instruction-beginning-c part: end */
46649 
46650 
46651     /* User code for *bnziu/fR*-no-fast-branches . */
46652 #line 3700 "../../libpoke/pvm.jitter"
46653 
46654     pvm_val tmp = JITTER_TOP_STACK ();
46655     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_UINT (tmp), JITTER_ARGF0);
46656 
46657     /* End of the user code for *bnziu/fR*-no-fast-branches . */
46658 
46659 /* User-specified code, instruction-end-c part: beginning. */
46660 
46661 /* User-specified code, instruction-end-c part: end */
46662 
46663 #ifdef JITTER_REPLICATE
46664     /* Advance the instruction pointer, if any, to skip residuals;
46665        then jump back to replicated code. */
46666     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
46667     JITTER_SKIP_RESIDUALS_;
46668     goto * _jitter_back_to_replicated_code_pointer;
46669 #endif // #ifdef JITTER_REPLICATE
46670 
46671     /* Undefine the *bnziu/fR*-no-fast-branches argument macros so they can't be used
46672        by mistake in the instruction body coming next. */
46673 #   undef JITTER_SLOW_REGISTER_OFFSET0
46674 #   undef JITTER_ARG0
46675 #   undef JITTER_ARGN0
46676 #   undef JITTER_ARGU0
46677 #   undef JITTER_ARGP0
46678 #   undef JITTER_ARGF0
46679 
46680 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46681 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46682 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46683 
46684   }
46685 #ifndef JITTER_REPLICATE
46686  JITTER_INSTRUCTION_EPILOG_(*bnziu/fR*-no-fast-branches, _Abnziu__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46687 #endif // #ifndef JITTER_REPLICATE
46688 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46689 
46690   JITTER_INSTRUCTION_PROLOG_(*bnzl/fR*-no-fast-branches, _Abnzl__fR_A_mno_mfast_mbranches, hot)
46691   {
46692     /* This specialized instruction is a replacement. */
46693 #   undef JITTER_BRANCH_FAST
46694 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46695 #   undef JITTER_BRANCH_FAST_IF_ZERO
46696 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46697 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46698 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46699 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46700 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46701 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46702 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46703 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46704 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46705 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46706 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46707 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46708 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46709 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46710 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46711 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46712 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46713 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46714 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46715 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46716 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46717 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46718 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46719 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46720 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46721 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46722 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46723 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46724 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46725 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46726 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46727 #   undef JITTER_BRANCH_FAST_IF_AND
46728 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46729 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46730 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46731 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46732 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46733 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46734 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46735 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46736 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46737 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46738 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46739 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46740 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46741 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46742 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46743 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46744 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46745 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46746 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46747 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46748 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46749 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46750 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46751 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46752 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46753 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46754 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46755 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46756 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46757     /* This specialized instruction is non-relocatable.
46758        Its 0-th argument, a literal, is the return address where to jump
46759        at the end, back to relocated code. */
46760 
46761 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       323
46762 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bnzl/fR*-no-fast-branches
46763 
46764 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abnzl__fR_A_mno_mfast_mbranches
46765 
46766   /* The residual arity for this instruction does not depend on fast labels. */
46767   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46768 
46769   /* Define argument-access macros for *bnzl/fR*-no-fast-branches . */
46770 #ifdef JITTER_HAVE_PATCH_IN
46771   /* Define argument-access macros assuming that fast branches are enabled. */
46772     /* The 0th argument is a residual label. */
46773 #if defined(JITTER_DISPATCH_NO_THREADING)
46774 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46775     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46776 #elif defined (JITTER_REPLICATE)
46777 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46778 #else
46779 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46780 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46781 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46782 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46783 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46784 #   define JITTER_ARGF0 JITTER_ARGP0
46785 
46786 #else
46787   /* Define argument-access macros assuming that fast branches are disabled. */
46788     /* The 0th argument is a residual label. */
46789 #if defined(JITTER_DISPATCH_NO_THREADING)
46790 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46791     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46792 #elif defined (JITTER_REPLICATE)
46793 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46794 #else
46795 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46796 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46797 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46798 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46799 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46800 #   define JITTER_ARGF0 JITTER_ARGP0
46801 
46802 # endif // #ifdef JITTER_HAVE_PATCH_IN
46803 
46804 #ifdef JITTER_REPLICATE
46805     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46806        it on the stack rather than in read-only memory.  I had to do this to prevent
46807        a GCC 8 snapshot on SH from being too clever. */
46808     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46809     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46810        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46811        load the relocated part crashes.
46812                  mov.w     .L1667,r0
46813                  mov.l     @(r0,r15),r1
46814                  jmp       @r1
46815        r15 is the stack pointer.  The constant at .L1667 is
46816           .L1667:
46817                  .short    232
46818        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46819        can't work as an immediate.  Shall I keep these code pointers as a single array?
46820        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46821        but the problem will be the same. */
46822     /* Jump to non-relocatable code. */
46823     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46824 
46825     /* Here the residual arity is given as zero: it's too late to
46826        skip residuals, since we've already jumped and this code is
46827        unreachable.  The instruction pointer, if any, is advanced
46828        in the non-relocatable code. */
46829     JITTER_INSTRUCTION_EPILOG_(*bnzl/fR*-no-fast-branches, _Abnzl__fR_A_mno_mfast_mbranches, 0)
46830 
46831     /* Relocated code will jump to this label in non-relocated code. */
46832   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46833     JITTER_COMMENT_IN_ASM_("*bnzl/fR*-no-fast-branches non-relocatable code");
46834 #endif // #ifdef JITTER_REPLICATE
46835 #if defined (JITTER_PROFILE_SAMPLE)
46836   JITTER_PROFILE_SAMPLE_UPDATE
46837      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46838       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46839   /* Force the compiler not move sample-profiling instrumentation
46840      beyond this point; this way the actual user code is timed.
46841      This is still not perfect, as residuals are materialised before
46842      we arrive here, but should be adequate at least for slow VM
46843      instructions. */
46844   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46845 #endif
46846 #if defined (JITTER_PROFILE_COUNT)
46847   /* Notice that, differently from the code above, this
46848      instrumentation code *can* be reordered freely: as long as a
46849      VM instruction is counted, the count increment can be placed
46850      anyehere.  Let GCC move this code and possibly achieve better
46851      throughput by exploiting instruction-level parallelism and
46852      therefore approximate more closely a non-profiled build. */
46853   JITTER_PROFILE_COUNT_UPDATE
46854      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46855       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46856 #endif
46857 
46858 /* User-specified code, instruction-beginning-c part: beginning. */
46859 
46860 /* User-specified code, instruction-beginning-c part: end */
46861 
46862 
46863     /* User code for *bnzl/fR*-no-fast-branches . */
46864 #line 3714 "../../libpoke/pvm.jitter"
46865 
46866     pvm_val tmp = JITTER_TOP_STACK ();
46867     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_LONG (tmp), JITTER_ARGF0);
46868 
46869     /* End of the user code for *bnzl/fR*-no-fast-branches . */
46870 
46871 /* User-specified code, instruction-end-c part: beginning. */
46872 
46873 /* User-specified code, instruction-end-c part: end */
46874 
46875 #ifdef JITTER_REPLICATE
46876     /* Advance the instruction pointer, if any, to skip residuals;
46877        then jump back to replicated code. */
46878     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
46879     JITTER_SKIP_RESIDUALS_;
46880     goto * _jitter_back_to_replicated_code_pointer;
46881 #endif // #ifdef JITTER_REPLICATE
46882 
46883     /* Undefine the *bnzl/fR*-no-fast-branches argument macros so they can't be used
46884        by mistake in the instruction body coming next. */
46885 #   undef JITTER_SLOW_REGISTER_OFFSET0
46886 #   undef JITTER_ARG0
46887 #   undef JITTER_ARGN0
46888 #   undef JITTER_ARGU0
46889 #   undef JITTER_ARGP0
46890 #   undef JITTER_ARGF0
46891 
46892 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46893 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46894 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46895 
46896   }
46897 #ifndef JITTER_REPLICATE
46898  JITTER_INSTRUCTION_EPILOG_(*bnzl/fR*-no-fast-branches, _Abnzl__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46899 #endif // #ifndef JITTER_REPLICATE
46900 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46901 
46902   JITTER_INSTRUCTION_PROLOG_(*bnzlu/fR*-no-fast-branches, _Abnzlu__fR_A_mno_mfast_mbranches, hot)
46903   {
46904     /* This specialized instruction is a replacement. */
46905 #   undef JITTER_BRANCH_FAST
46906 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46907 #   undef JITTER_BRANCH_FAST_IF_ZERO
46908 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46909 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46910 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46911 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46912 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46913 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46914 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46915 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46916 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46917 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46918 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46919 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46920 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46921 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46922 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46923 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46924 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46925 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46926 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46927 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46928 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46929 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46930 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46931 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46932 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46933 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46934 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46935 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46936 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46937 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46938 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46939 #   undef JITTER_BRANCH_FAST_IF_AND
46940 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46941 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46942 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46943 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46944 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46945 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46946 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46947 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46948 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46949 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46950 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46951 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46952 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46953 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46954 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46955 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46956 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46957 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46958 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46959 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46960 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46961 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46962 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46963 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46964 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46965 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46966 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46967 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46968 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46969     /* This specialized instruction is non-relocatable.
46970        Its 0-th argument, a literal, is the return address where to jump
46971        at the end, back to relocated code. */
46972 
46973 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       324
46974 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bnzlu/fR*-no-fast-branches
46975 
46976 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abnzlu__fR_A_mno_mfast_mbranches
46977 
46978   /* The residual arity for this instruction does not depend on fast labels. */
46979   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46980 
46981   /* Define argument-access macros for *bnzlu/fR*-no-fast-branches . */
46982 #ifdef JITTER_HAVE_PATCH_IN
46983   /* Define argument-access macros assuming that fast branches are enabled. */
46984     /* The 0th argument is a residual label. */
46985 #if defined(JITTER_DISPATCH_NO_THREADING)
46986 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46987     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46988 #elif defined (JITTER_REPLICATE)
46989 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46990 #else
46991 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46992 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46993 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46994 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46995 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46996 #   define JITTER_ARGF0 JITTER_ARGP0
46997 
46998 #else
46999   /* Define argument-access macros assuming that fast branches are disabled. */
47000     /* The 0th argument is a residual label. */
47001 #if defined(JITTER_DISPATCH_NO_THREADING)
47002 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47003     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47004 #elif defined (JITTER_REPLICATE)
47005 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47006 #else
47007 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47008 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47009 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47010 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47011 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47012 #   define JITTER_ARGF0 JITTER_ARGP0
47013 
47014 # endif // #ifdef JITTER_HAVE_PATCH_IN
47015 
47016 #ifdef JITTER_REPLICATE
47017     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47018        it on the stack rather than in read-only memory.  I had to do this to prevent
47019        a GCC 8 snapshot on SH from being too clever. */
47020     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47021     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47022        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47023        load the relocated part crashes.
47024                  mov.w     .L1667,r0
47025                  mov.l     @(r0,r15),r1
47026                  jmp       @r1
47027        r15 is the stack pointer.  The constant at .L1667 is
47028           .L1667:
47029                  .short    232
47030        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47031        can't work as an immediate.  Shall I keep these code pointers as a single array?
47032        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47033        but the problem will be the same. */
47034     /* Jump to non-relocatable code. */
47035     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47036 
47037     /* Here the residual arity is given as zero: it's too late to
47038        skip residuals, since we've already jumped and this code is
47039        unreachable.  The instruction pointer, if any, is advanced
47040        in the non-relocatable code. */
47041     JITTER_INSTRUCTION_EPILOG_(*bnzlu/fR*-no-fast-branches, _Abnzlu__fR_A_mno_mfast_mbranches, 0)
47042 
47043     /* Relocated code will jump to this label in non-relocated code. */
47044   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47045     JITTER_COMMENT_IN_ASM_("*bnzlu/fR*-no-fast-branches non-relocatable code");
47046 #endif // #ifdef JITTER_REPLICATE
47047 #if defined (JITTER_PROFILE_SAMPLE)
47048   JITTER_PROFILE_SAMPLE_UPDATE
47049      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47050       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47051   /* Force the compiler not move sample-profiling instrumentation
47052      beyond this point; this way the actual user code is timed.
47053      This is still not perfect, as residuals are materialised before
47054      we arrive here, but should be adequate at least for slow VM
47055      instructions. */
47056   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47057 #endif
47058 #if defined (JITTER_PROFILE_COUNT)
47059   /* Notice that, differently from the code above, this
47060      instrumentation code *can* be reordered freely: as long as a
47061      VM instruction is counted, the count increment can be placed
47062      anyehere.  Let GCC move this code and possibly achieve better
47063      throughput by exploiting instruction-level parallelism and
47064      therefore approximate more closely a non-profiled build. */
47065   JITTER_PROFILE_COUNT_UPDATE
47066      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47067       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47068 #endif
47069 
47070 /* User-specified code, instruction-beginning-c part: beginning. */
47071 
47072 /* User-specified code, instruction-beginning-c part: end */
47073 
47074 
47075     /* User code for *bnzlu/fR*-no-fast-branches . */
47076 #line 3728 "../../libpoke/pvm.jitter"
47077 
47078     pvm_val tmp = JITTER_TOP_STACK ();
47079     JITTER_BRANCH_FAST_IF_NONZERO (PVM_VAL_ULONG (tmp), JITTER_ARGF0);
47080 
47081     /* End of the user code for *bnzlu/fR*-no-fast-branches . */
47082 
47083 /* User-specified code, instruction-end-c part: beginning. */
47084 
47085 /* User-specified code, instruction-end-c part: end */
47086 
47087 #ifdef JITTER_REPLICATE
47088     /* Advance the instruction pointer, if any, to skip residuals;
47089        then jump back to replicated code. */
47090     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
47091     JITTER_SKIP_RESIDUALS_;
47092     goto * _jitter_back_to_replicated_code_pointer;
47093 #endif // #ifdef JITTER_REPLICATE
47094 
47095     /* Undefine the *bnzlu/fR*-no-fast-branches argument macros so they can't be used
47096        by mistake in the instruction body coming next. */
47097 #   undef JITTER_SLOW_REGISTER_OFFSET0
47098 #   undef JITTER_ARG0
47099 #   undef JITTER_ARGN0
47100 #   undef JITTER_ARGU0
47101 #   undef JITTER_ARGP0
47102 #   undef JITTER_ARGF0
47103 
47104 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47105 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47106 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47107 
47108   }
47109 #ifndef JITTER_REPLICATE
47110  JITTER_INSTRUCTION_EPILOG_(*bnzlu/fR*-no-fast-branches, _Abnzlu__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47111 #endif // #ifndef JITTER_REPLICATE
47112 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47113 
47114   JITTER_INSTRUCTION_PROLOG_(*bzi/fR*-no-fast-branches, _Abzi__fR_A_mno_mfast_mbranches, hot)
47115   {
47116     /* This specialized instruction is a replacement. */
47117 #   undef JITTER_BRANCH_FAST
47118 #   define JITTER_BRANCH_FAST JITTER_BRANCH
47119 #   undef JITTER_BRANCH_FAST_IF_ZERO
47120 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
47121 #   undef JITTER_BRANCH_FAST_IF_NONZERO
47122 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
47123 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
47124 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
47125 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
47126 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
47127 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
47128 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
47129 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
47130 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
47131 #   undef JITTER_BRANCH_FAST_IF_EQUAL
47132 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
47133 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47134 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47135 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47136 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47137 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47138 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47139 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47140 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47141 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47142 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47143 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47144 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47145 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47146 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47147 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47148 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47149 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47150 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47151 #   undef JITTER_BRANCH_FAST_IF_AND
47152 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47153 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47154 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47155 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47156 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47157 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47158 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47159 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47160 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47161 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47162 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47163 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47164 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47165 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47166 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47167 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47168 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47169 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47170 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47171 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47172 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47173 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47174 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47175 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47176 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47177 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47178 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47179 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47180 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47181     /* This specialized instruction is non-relocatable.
47182        Its 0-th argument, a literal, is the return address where to jump
47183        at the end, back to relocated code. */
47184 
47185 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       325
47186 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bzi/fR*-no-fast-branches
47187 
47188 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abzi__fR_A_mno_mfast_mbranches
47189 
47190   /* The residual arity for this instruction does not depend on fast labels. */
47191   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
47192 
47193   /* Define argument-access macros for *bzi/fR*-no-fast-branches . */
47194 #ifdef JITTER_HAVE_PATCH_IN
47195   /* Define argument-access macros assuming that fast branches are enabled. */
47196     /* The 0th argument is a residual label. */
47197 #if defined(JITTER_DISPATCH_NO_THREADING)
47198 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47199     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47200 #elif defined (JITTER_REPLICATE)
47201 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47202 #else
47203 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47204 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47205 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47206 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47207 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47208 #   define JITTER_ARGF0 JITTER_ARGP0
47209 
47210 #else
47211   /* Define argument-access macros assuming that fast branches are disabled. */
47212     /* The 0th argument is a residual label. */
47213 #if defined(JITTER_DISPATCH_NO_THREADING)
47214 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47215     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47216 #elif defined (JITTER_REPLICATE)
47217 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47218 #else
47219 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47220 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47221 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47222 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47223 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47224 #   define JITTER_ARGF0 JITTER_ARGP0
47225 
47226 # endif // #ifdef JITTER_HAVE_PATCH_IN
47227 
47228 #ifdef JITTER_REPLICATE
47229     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47230        it on the stack rather than in read-only memory.  I had to do this to prevent
47231        a GCC 8 snapshot on SH from being too clever. */
47232     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47233     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47234        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47235        load the relocated part crashes.
47236                  mov.w     .L1667,r0
47237                  mov.l     @(r0,r15),r1
47238                  jmp       @r1
47239        r15 is the stack pointer.  The constant at .L1667 is
47240           .L1667:
47241                  .short    232
47242        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47243        can't work as an immediate.  Shall I keep these code pointers as a single array?
47244        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47245        but the problem will be the same. */
47246     /* Jump to non-relocatable code. */
47247     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47248 
47249     /* Here the residual arity is given as zero: it's too late to
47250        skip residuals, since we've already jumped and this code is
47251        unreachable.  The instruction pointer, if any, is advanced
47252        in the non-relocatable code. */
47253     JITTER_INSTRUCTION_EPILOG_(*bzi/fR*-no-fast-branches, _Abzi__fR_A_mno_mfast_mbranches, 0)
47254 
47255     /* Relocated code will jump to this label in non-relocated code. */
47256   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47257     JITTER_COMMENT_IN_ASM_("*bzi/fR*-no-fast-branches non-relocatable code");
47258 #endif // #ifdef JITTER_REPLICATE
47259 #if defined (JITTER_PROFILE_SAMPLE)
47260   JITTER_PROFILE_SAMPLE_UPDATE
47261      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47262       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47263   /* Force the compiler not move sample-profiling instrumentation
47264      beyond this point; this way the actual user code is timed.
47265      This is still not perfect, as residuals are materialised before
47266      we arrive here, but should be adequate at least for slow VM
47267      instructions. */
47268   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47269 #endif
47270 #if defined (JITTER_PROFILE_COUNT)
47271   /* Notice that, differently from the code above, this
47272      instrumentation code *can* be reordered freely: as long as a
47273      VM instruction is counted, the count increment can be placed
47274      anyehere.  Let GCC move this code and possibly achieve better
47275      throughput by exploiting instruction-level parallelism and
47276      therefore approximate more closely a non-profiled build. */
47277   JITTER_PROFILE_COUNT_UPDATE
47278      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47279       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47280 #endif
47281 
47282 /* User-specified code, instruction-beginning-c part: beginning. */
47283 
47284 /* User-specified code, instruction-beginning-c part: end */
47285 
47286 
47287     /* User code for *bzi/fR*-no-fast-branches . */
47288 #line 3630 "../../libpoke/pvm.jitter"
47289 
47290     pvm_val tmp = JITTER_TOP_STACK ();
47291     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_INT (tmp), JITTER_ARGF0);
47292 
47293     /* End of the user code for *bzi/fR*-no-fast-branches . */
47294 
47295 /* User-specified code, instruction-end-c part: beginning. */
47296 
47297 /* User-specified code, instruction-end-c part: end */
47298 
47299 #ifdef JITTER_REPLICATE
47300     /* Advance the instruction pointer, if any, to skip residuals;
47301        then jump back to replicated code. */
47302     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
47303     JITTER_SKIP_RESIDUALS_;
47304     goto * _jitter_back_to_replicated_code_pointer;
47305 #endif // #ifdef JITTER_REPLICATE
47306 
47307     /* Undefine the *bzi/fR*-no-fast-branches argument macros so they can't be used
47308        by mistake in the instruction body coming next. */
47309 #   undef JITTER_SLOW_REGISTER_OFFSET0
47310 #   undef JITTER_ARG0
47311 #   undef JITTER_ARGN0
47312 #   undef JITTER_ARGU0
47313 #   undef JITTER_ARGP0
47314 #   undef JITTER_ARGF0
47315 
47316 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47317 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47318 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47319 
47320   }
47321 #ifndef JITTER_REPLICATE
47322  JITTER_INSTRUCTION_EPILOG_(*bzi/fR*-no-fast-branches, _Abzi__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47323 #endif // #ifndef JITTER_REPLICATE
47324 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47325 
47326   JITTER_INSTRUCTION_PROLOG_(*bziu/fR*-no-fast-branches, _Abziu__fR_A_mno_mfast_mbranches, hot)
47327   {
47328     /* This specialized instruction is a replacement. */
47329 #   undef JITTER_BRANCH_FAST
47330 #   define JITTER_BRANCH_FAST JITTER_BRANCH
47331 #   undef JITTER_BRANCH_FAST_IF_ZERO
47332 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
47333 #   undef JITTER_BRANCH_FAST_IF_NONZERO
47334 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
47335 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
47336 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
47337 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
47338 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
47339 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
47340 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
47341 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
47342 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
47343 #   undef JITTER_BRANCH_FAST_IF_EQUAL
47344 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
47345 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47346 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47347 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47348 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47349 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47350 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47351 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47352 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47353 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47354 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47355 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47356 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47357 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47358 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47359 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47360 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47361 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47362 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47363 #   undef JITTER_BRANCH_FAST_IF_AND
47364 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47365 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47366 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47367 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47368 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47369 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47370 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47371 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47372 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47373 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47374 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47375 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47376 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47377 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47378 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47379 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47380 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47381 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47382 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47383 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47384 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47385 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47386 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47387 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47388 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47389 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47390 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47391 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47392 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47393     /* This specialized instruction is non-relocatable.
47394        Its 0-th argument, a literal, is the return address where to jump
47395        at the end, back to relocated code. */
47396 
47397 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       326
47398 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bziu/fR*-no-fast-branches
47399 
47400 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abziu__fR_A_mno_mfast_mbranches
47401 
47402   /* The residual arity for this instruction does not depend on fast labels. */
47403   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
47404 
47405   /* Define argument-access macros for *bziu/fR*-no-fast-branches . */
47406 #ifdef JITTER_HAVE_PATCH_IN
47407   /* Define argument-access macros assuming that fast branches are enabled. */
47408     /* The 0th argument is a residual label. */
47409 #if defined(JITTER_DISPATCH_NO_THREADING)
47410 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47411     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47412 #elif defined (JITTER_REPLICATE)
47413 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47414 #else
47415 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47416 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47417 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47418 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47419 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47420 #   define JITTER_ARGF0 JITTER_ARGP0
47421 
47422 #else
47423   /* Define argument-access macros assuming that fast branches are disabled. */
47424     /* The 0th argument is a residual label. */
47425 #if defined(JITTER_DISPATCH_NO_THREADING)
47426 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47427     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47428 #elif defined (JITTER_REPLICATE)
47429 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47430 #else
47431 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47432 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47433 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47434 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47435 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47436 #   define JITTER_ARGF0 JITTER_ARGP0
47437 
47438 # endif // #ifdef JITTER_HAVE_PATCH_IN
47439 
47440 #ifdef JITTER_REPLICATE
47441     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47442        it on the stack rather than in read-only memory.  I had to do this to prevent
47443        a GCC 8 snapshot on SH from being too clever. */
47444     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47445     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47446        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47447        load the relocated part crashes.
47448                  mov.w     .L1667,r0
47449                  mov.l     @(r0,r15),r1
47450                  jmp       @r1
47451        r15 is the stack pointer.  The constant at .L1667 is
47452           .L1667:
47453                  .short    232
47454        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47455        can't work as an immediate.  Shall I keep these code pointers as a single array?
47456        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47457        but the problem will be the same. */
47458     /* Jump to non-relocatable code. */
47459     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47460 
47461     /* Here the residual arity is given as zero: it's too late to
47462        skip residuals, since we've already jumped and this code is
47463        unreachable.  The instruction pointer, if any, is advanced
47464        in the non-relocatable code. */
47465     JITTER_INSTRUCTION_EPILOG_(*bziu/fR*-no-fast-branches, _Abziu__fR_A_mno_mfast_mbranches, 0)
47466 
47467     /* Relocated code will jump to this label in non-relocated code. */
47468   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47469     JITTER_COMMENT_IN_ASM_("*bziu/fR*-no-fast-branches non-relocatable code");
47470 #endif // #ifdef JITTER_REPLICATE
47471 #if defined (JITTER_PROFILE_SAMPLE)
47472   JITTER_PROFILE_SAMPLE_UPDATE
47473      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47474       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47475   /* Force the compiler not move sample-profiling instrumentation
47476      beyond this point; this way the actual user code is timed.
47477      This is still not perfect, as residuals are materialised before
47478      we arrive here, but should be adequate at least for slow VM
47479      instructions. */
47480   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47481 #endif
47482 #if defined (JITTER_PROFILE_COUNT)
47483   /* Notice that, differently from the code above, this
47484      instrumentation code *can* be reordered freely: as long as a
47485      VM instruction is counted, the count increment can be placed
47486      anyehere.  Let GCC move this code and possibly achieve better
47487      throughput by exploiting instruction-level parallelism and
47488      therefore approximate more closely a non-profiled build. */
47489   JITTER_PROFILE_COUNT_UPDATE
47490      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47491       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47492 #endif
47493 
47494 /* User-specified code, instruction-beginning-c part: beginning. */
47495 
47496 /* User-specified code, instruction-beginning-c part: end */
47497 
47498 
47499     /* User code for *bziu/fR*-no-fast-branches . */
47500 #line 3644 "../../libpoke/pvm.jitter"
47501 
47502     pvm_val tmp = JITTER_TOP_STACK ();
47503     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_UINT (tmp), JITTER_ARGF0);
47504 
47505     /* End of the user code for *bziu/fR*-no-fast-branches . */
47506 
47507 /* User-specified code, instruction-end-c part: beginning. */
47508 
47509 /* User-specified code, instruction-end-c part: end */
47510 
47511 #ifdef JITTER_REPLICATE
47512     /* Advance the instruction pointer, if any, to skip residuals;
47513        then jump back to replicated code. */
47514     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
47515     JITTER_SKIP_RESIDUALS_;
47516     goto * _jitter_back_to_replicated_code_pointer;
47517 #endif // #ifdef JITTER_REPLICATE
47518 
47519     /* Undefine the *bziu/fR*-no-fast-branches argument macros so they can't be used
47520        by mistake in the instruction body coming next. */
47521 #   undef JITTER_SLOW_REGISTER_OFFSET0
47522 #   undef JITTER_ARG0
47523 #   undef JITTER_ARGN0
47524 #   undef JITTER_ARGU0
47525 #   undef JITTER_ARGP0
47526 #   undef JITTER_ARGF0
47527 
47528 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47529 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47530 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47531 
47532   }
47533 #ifndef JITTER_REPLICATE
47534  JITTER_INSTRUCTION_EPILOG_(*bziu/fR*-no-fast-branches, _Abziu__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47535 #endif // #ifndef JITTER_REPLICATE
47536 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47537 
47538   JITTER_INSTRUCTION_PROLOG_(*bzl/fR*-no-fast-branches, _Abzl__fR_A_mno_mfast_mbranches, hot)
47539   {
47540     /* This specialized instruction is a replacement. */
47541 #   undef JITTER_BRANCH_FAST
47542 #   define JITTER_BRANCH_FAST JITTER_BRANCH
47543 #   undef JITTER_BRANCH_FAST_IF_ZERO
47544 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
47545 #   undef JITTER_BRANCH_FAST_IF_NONZERO
47546 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
47547 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
47548 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
47549 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
47550 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
47551 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
47552 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
47553 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
47554 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
47555 #   undef JITTER_BRANCH_FAST_IF_EQUAL
47556 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
47557 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47558 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47559 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47560 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47561 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47562 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47563 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47564 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47565 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47566 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47567 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47568 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47569 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47570 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47571 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47572 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47573 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47574 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47575 #   undef JITTER_BRANCH_FAST_IF_AND
47576 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47577 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47578 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47579 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47580 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47581 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47582 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47583 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47584 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47585 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47586 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47587 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47588 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47589 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47590 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47591 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47592 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47593 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47594 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47595 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47596 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47597 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47598 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47599 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47600 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47601 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47602 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47603 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47604 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47605     /* This specialized instruction is non-relocatable.
47606        Its 0-th argument, a literal, is the return address where to jump
47607        at the end, back to relocated code. */
47608 
47609 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       327
47610 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bzl/fR*-no-fast-branches
47611 
47612 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abzl__fR_A_mno_mfast_mbranches
47613 
47614   /* The residual arity for this instruction does not depend on fast labels. */
47615   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
47616 
47617   /* Define argument-access macros for *bzl/fR*-no-fast-branches . */
47618 #ifdef JITTER_HAVE_PATCH_IN
47619   /* Define argument-access macros assuming that fast branches are enabled. */
47620     /* The 0th argument is a residual label. */
47621 #if defined(JITTER_DISPATCH_NO_THREADING)
47622 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47623     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47624 #elif defined (JITTER_REPLICATE)
47625 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47626 #else
47627 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47628 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47629 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47630 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47631 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47632 #   define JITTER_ARGF0 JITTER_ARGP0
47633 
47634 #else
47635   /* Define argument-access macros assuming that fast branches are disabled. */
47636     /* The 0th argument is a residual label. */
47637 #if defined(JITTER_DISPATCH_NO_THREADING)
47638 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47639     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47640 #elif defined (JITTER_REPLICATE)
47641 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47642 #else
47643 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47644 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47645 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47646 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47647 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47648 #   define JITTER_ARGF0 JITTER_ARGP0
47649 
47650 # endif // #ifdef JITTER_HAVE_PATCH_IN
47651 
47652 #ifdef JITTER_REPLICATE
47653     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47654        it on the stack rather than in read-only memory.  I had to do this to prevent
47655        a GCC 8 snapshot on SH from being too clever. */
47656     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47657     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47658        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47659        load the relocated part crashes.
47660                  mov.w     .L1667,r0
47661                  mov.l     @(r0,r15),r1
47662                  jmp       @r1
47663        r15 is the stack pointer.  The constant at .L1667 is
47664           .L1667:
47665                  .short    232
47666        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47667        can't work as an immediate.  Shall I keep these code pointers as a single array?
47668        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47669        but the problem will be the same. */
47670     /* Jump to non-relocatable code. */
47671     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47672 
47673     /* Here the residual arity is given as zero: it's too late to
47674        skip residuals, since we've already jumped and this code is
47675        unreachable.  The instruction pointer, if any, is advanced
47676        in the non-relocatable code. */
47677     JITTER_INSTRUCTION_EPILOG_(*bzl/fR*-no-fast-branches, _Abzl__fR_A_mno_mfast_mbranches, 0)
47678 
47679     /* Relocated code will jump to this label in non-relocated code. */
47680   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47681     JITTER_COMMENT_IN_ASM_("*bzl/fR*-no-fast-branches non-relocatable code");
47682 #endif // #ifdef JITTER_REPLICATE
47683 #if defined (JITTER_PROFILE_SAMPLE)
47684   JITTER_PROFILE_SAMPLE_UPDATE
47685      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47686       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47687   /* Force the compiler not move sample-profiling instrumentation
47688      beyond this point; this way the actual user code is timed.
47689      This is still not perfect, as residuals are materialised before
47690      we arrive here, but should be adequate at least for slow VM
47691      instructions. */
47692   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47693 #endif
47694 #if defined (JITTER_PROFILE_COUNT)
47695   /* Notice that, differently from the code above, this
47696      instrumentation code *can* be reordered freely: as long as a
47697      VM instruction is counted, the count increment can be placed
47698      anyehere.  Let GCC move this code and possibly achieve better
47699      throughput by exploiting instruction-level parallelism and
47700      therefore approximate more closely a non-profiled build. */
47701   JITTER_PROFILE_COUNT_UPDATE
47702      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47703       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47704 #endif
47705 
47706 /* User-specified code, instruction-beginning-c part: beginning. */
47707 
47708 /* User-specified code, instruction-beginning-c part: end */
47709 
47710 
47711     /* User code for *bzl/fR*-no-fast-branches . */
47712 #line 3658 "../../libpoke/pvm.jitter"
47713 
47714     pvm_val tmp = JITTER_TOP_STACK ();
47715     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_LONG (tmp), JITTER_ARGF0);
47716 
47717     /* End of the user code for *bzl/fR*-no-fast-branches . */
47718 
47719 /* User-specified code, instruction-end-c part: beginning. */
47720 
47721 /* User-specified code, instruction-end-c part: end */
47722 
47723 #ifdef JITTER_REPLICATE
47724     /* Advance the instruction pointer, if any, to skip residuals;
47725        then jump back to replicated code. */
47726     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
47727     JITTER_SKIP_RESIDUALS_;
47728     goto * _jitter_back_to_replicated_code_pointer;
47729 #endif // #ifdef JITTER_REPLICATE
47730 
47731     /* Undefine the *bzl/fR*-no-fast-branches argument macros so they can't be used
47732        by mistake in the instruction body coming next. */
47733 #   undef JITTER_SLOW_REGISTER_OFFSET0
47734 #   undef JITTER_ARG0
47735 #   undef JITTER_ARGN0
47736 #   undef JITTER_ARGU0
47737 #   undef JITTER_ARGP0
47738 #   undef JITTER_ARGF0
47739 
47740 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47741 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47742 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47743 
47744   }
47745 #ifndef JITTER_REPLICATE
47746  JITTER_INSTRUCTION_EPILOG_(*bzl/fR*-no-fast-branches, _Abzl__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47747 #endif // #ifndef JITTER_REPLICATE
47748 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47749 
47750   JITTER_INSTRUCTION_PROLOG_(*bzlu/fR*-no-fast-branches, _Abzlu__fR_A_mno_mfast_mbranches, hot)
47751   {
47752     /* This specialized instruction is a replacement. */
47753 #   undef JITTER_BRANCH_FAST
47754 #   define JITTER_BRANCH_FAST JITTER_BRANCH
47755 #   undef JITTER_BRANCH_FAST_IF_ZERO
47756 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
47757 #   undef JITTER_BRANCH_FAST_IF_NONZERO
47758 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
47759 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
47760 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
47761 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
47762 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
47763 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
47764 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
47765 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
47766 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
47767 #   undef JITTER_BRANCH_FAST_IF_EQUAL
47768 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
47769 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47770 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47771 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47772 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47773 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47774 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47775 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47776 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47777 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47778 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47779 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47780 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47781 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47782 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47783 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47784 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47785 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47786 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47787 #   undef JITTER_BRANCH_FAST_IF_AND
47788 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47789 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47790 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47791 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47792 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47793 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47794 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47795 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47796 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47797 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47798 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47799 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47800 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47801 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47802 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47803 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47804 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47805 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47806 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47807 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47808 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47809 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47810 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47811 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47812 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47813 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47814 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47815 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47816 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47817     /* This specialized instruction is non-relocatable.
47818        Its 0-th argument, a literal, is the return address where to jump
47819        at the end, back to relocated code. */
47820 
47821 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       328
47822 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *bzlu/fR*-no-fast-branches
47823 
47824 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abzlu__fR_A_mno_mfast_mbranches
47825 
47826   /* The residual arity for this instruction does not depend on fast labels. */
47827   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
47828 
47829   /* Define argument-access macros for *bzlu/fR*-no-fast-branches . */
47830 #ifdef JITTER_HAVE_PATCH_IN
47831   /* Define argument-access macros assuming that fast branches are enabled. */
47832     /* The 0th argument is a residual label. */
47833 #if defined(JITTER_DISPATCH_NO_THREADING)
47834 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47835     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47836 #elif defined (JITTER_REPLICATE)
47837 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47838 #else
47839 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47840 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47841 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47842 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47843 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47844 #   define JITTER_ARGF0 JITTER_ARGP0
47845 
47846 #else
47847   /* Define argument-access macros assuming that fast branches are disabled. */
47848     /* The 0th argument is a residual label. */
47849 #if defined(JITTER_DISPATCH_NO_THREADING)
47850 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47851     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47852 #elif defined (JITTER_REPLICATE)
47853 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47854 #else
47855 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47856 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47857 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47858 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47859 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47860 #   define JITTER_ARGF0 JITTER_ARGP0
47861 
47862 # endif // #ifdef JITTER_HAVE_PATCH_IN
47863 
47864 #ifdef JITTER_REPLICATE
47865     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47866        it on the stack rather than in read-only memory.  I had to do this to prevent
47867        a GCC 8 snapshot on SH from being too clever. */
47868     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47869     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47870        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47871        load the relocated part crashes.
47872                  mov.w     .L1667,r0
47873                  mov.l     @(r0,r15),r1
47874                  jmp       @r1
47875        r15 is the stack pointer.  The constant at .L1667 is
47876           .L1667:
47877                  .short    232
47878        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47879        can't work as an immediate.  Shall I keep these code pointers as a single array?
47880        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47881        but the problem will be the same. */
47882     /* Jump to non-relocatable code. */
47883     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47884 
47885     /* Here the residual arity is given as zero: it's too late to
47886        skip residuals, since we've already jumped and this code is
47887        unreachable.  The instruction pointer, if any, is advanced
47888        in the non-relocatable code. */
47889     JITTER_INSTRUCTION_EPILOG_(*bzlu/fR*-no-fast-branches, _Abzlu__fR_A_mno_mfast_mbranches, 0)
47890 
47891     /* Relocated code will jump to this label in non-relocated code. */
47892   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47893     JITTER_COMMENT_IN_ASM_("*bzlu/fR*-no-fast-branches non-relocatable code");
47894 #endif // #ifdef JITTER_REPLICATE
47895 #if defined (JITTER_PROFILE_SAMPLE)
47896   JITTER_PROFILE_SAMPLE_UPDATE
47897      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47898       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47899   /* Force the compiler not move sample-profiling instrumentation
47900      beyond this point; this way the actual user code is timed.
47901      This is still not perfect, as residuals are materialised before
47902      we arrive here, but should be adequate at least for slow VM
47903      instructions. */
47904   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47905 #endif
47906 #if defined (JITTER_PROFILE_COUNT)
47907   /* Notice that, differently from the code above, this
47908      instrumentation code *can* be reordered freely: as long as a
47909      VM instruction is counted, the count increment can be placed
47910      anyehere.  Let GCC move this code and possibly achieve better
47911      throughput by exploiting instruction-level parallelism and
47912      therefore approximate more closely a non-profiled build. */
47913   JITTER_PROFILE_COUNT_UPDATE
47914      (PVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47915       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47916 #endif
47917 
47918 /* User-specified code, instruction-beginning-c part: beginning. */
47919 
47920 /* User-specified code, instruction-beginning-c part: end */
47921 
47922 
47923     /* User code for *bzlu/fR*-no-fast-branches . */
47924 #line 3672 "../../libpoke/pvm.jitter"
47925 
47926     pvm_val tmp = JITTER_TOP_STACK ();
47927     JITTER_BRANCH_FAST_IF_ZERO (PVM_VAL_ULONG (tmp), JITTER_ARGF0);
47928 
47929     /* End of the user code for *bzlu/fR*-no-fast-branches . */
47930 
47931 /* User-specified code, instruction-end-c part: beginning. */
47932 
47933 /* User-specified code, instruction-end-c part: end */
47934 
47935 #ifdef JITTER_REPLICATE
47936     /* Advance the instruction pointer, if any, to skip residuals;
47937        then jump back to replicated code. */
47938     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
47939     JITTER_SKIP_RESIDUALS_;
47940     goto * _jitter_back_to_replicated_code_pointer;
47941 #endif // #ifdef JITTER_REPLICATE
47942 
47943     /* Undefine the *bzlu/fR*-no-fast-branches argument macros so they can't be used
47944        by mistake in the instruction body coming next. */
47945 #   undef JITTER_SLOW_REGISTER_OFFSET0
47946 #   undef JITTER_ARG0
47947 #   undef JITTER_ARGN0
47948 #   undef JITTER_ARGU0
47949 #   undef JITTER_ARGP0
47950 #   undef JITTER_ARGF0
47951 
47952 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47953 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47954 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47955 
47956   }
47957 #ifndef JITTER_REPLICATE
47958  JITTER_INSTRUCTION_EPILOG_(*bzlu/fR*-no-fast-branches, _Abzlu__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47959 #endif // #ifndef JITTER_REPLICATE
47960 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47961 
47962   /* End of the ordinary specialized instructions. */
47963 
47964 #ifdef JITTER_DISPATCH_SWITCH
47965   default:
47966     jitter_fatal ("invalid opcode %li for VM specialized instruction",
47967                   (long) jitter_ip->fixnum);
47968   } /* switch */
47969 #endif // #ifdef JITTER_DISPATCH_SWITCH
47970 
47971   /* The code jumps here when executing the special specialized instruction
47972      EXITVM, or on a call to the macro JITTER_EXIT from an ordinary specialized
47973      instruction.  This code is *not* replicated: when replication is enabled
47974      jumping here means crossing the boundary from the fragaile replicated
47975      code back into ordinary compiled C, where PC-relative addressing works. */
47976   jitter_exit_vm_label: __attribute__ ((cold));
47977     JITTER_COMMENT_IN_ASM_("About to exit the function");
47978     // fprintf (stderr, "Restoring the VM state to the struct...\n");
47979     /* Copy the VM state from the local copy we have modified back to
47980        the structure to which we received a pointer. */
47981     jitter_original_state->pvm_state_runtime = jitter_state_runtime;
47982 
47983     // fprintf (stderr, "Exiting the VM...\n");
47984 
47985 
47986 #if defined (JITTER_PROFILE_SAMPLE)
47987     /* Stop sample-profiling: this stops the periodic timer signal, while
47988        we are no longer updating the current instruction field within the
47989        special-purpose struct in the Array. */
47990     pvm_profile_sample_stop ();
47991 #endif // #if defined (JITTER_PROFILE_SAMPLE)
47992 
47993 #ifndef JITTER_DISPATCH_SWITCH
47994   JITTER_DATA_LOCATION_FOOTER(pvm);
47995 #endif // #ifndef JITTER_DISPATCH_SWITCH
47996 #ifdef JITTER_HAVE_PATCH_IN
47997   /* Close the patch-in global definition for this executor.  This defines a
47998      new global in the patch-in subsection, holding the descriptor number.
47999      This is a global asm statement.  Same for defects.  See the comment before
48000       the JITTER_PATCH_IN_HEADER use above. */
48001   JITTER_PATCH_IN_FOOTER(pvm);
48002   JITTER_DEFECT_FOOTER(pvm);
48003 #endif // #ifdef JITTER_HAVE_PATCH_IN
48004 
48005   /* Finalization C code from the user */
48006   /* End of the finalization C code from the user */
48007 
48008 
48009   /* Execute architecture-specific execution-end code, if any.  Make
48010      sure it is safe to expand the macro without do..while (false). */
48011   {}; JITTER_EXECUTION_END_; {};
48012 
48013   /* This program point is reachable for both thread initialization and
48014      execution.  In either case it is not performance-critical. */
48015   jitter_possibly_restore_registers_and_return_label: __attribute__ ((cold));
48016     //if (jitter_initialize) puts ("-- RETURNING FROM INITIALIZATION\n");
48017 #ifdef JITTER_DISPATCH_NO_THREADING
48018     /* Back to regular C without our reserved registers: restore the
48019        values held in such registers at entry. */
48020     pvm_restore_registers (jitter_register_buffer);
48021 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
48022 #ifdef JITTER_PROFILE
48023 #define PROFILING_SPACE (1024 * 1024 * 100)
48024     if (jitter_initialize)
48025       fprintf (stderr, "Profiling space: [%p, %p)\n", && pvm_profiling_space, ((char *) (&& pvm_profiling_space)) + PROFILING_SPACE);
48026     /* Do an indirect jump to the return statement rather than a simple
48027        conditional.  With this trick I can afford even a very large gap
48028        within the code for a single C function, without being constrained
48029        by branch offset limits on any architecture. */
48030     void *return_address_variable = && return_label;
48031     JITTER_MARK_LVALUE_AS_SET_BY_ASSEMBLY (return_address_variable);
48032     goto *return_address_variable;
48033   pvm_profiling_space: __attribute__ ((unused)) // FIXME: do this from assembly
48034     asm volatile (".fill (" JITTER_STRINGIFY(PROFILING_SPACE) ")");
48035   return_label:
48036 #endif // #ifdef JITTER_PROFILE
48037     return;
48038 }
48039 
48040