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 
7 /* User-specified code, initial vm2 part: end */
8 
9 /* These two macros are convenient for making VM-specific identifiers
10    using VM-independent macros from a public header, without polluting
11    the global namespace. */
12 #define JITTER_VM_PREFIX_LOWER_CASE jitterlispvm
13 #define JITTER_VM_PREFIX_UPPER_CASE JITTERLISPVM
14 
15 //#include <config.h>
16 
17 #include <stdbool.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 
21 /* Early C code from the user. */
22 
23 #   include <stdio.h>
24 
25   /* End of the early C code from the user. */
26 
27 #include <jitter/jitter.h>
28 #include <jitter/jitter-instruction.h>
29 
30 #define JITTER_THIS_CAN_INCLUDE_JITTER_EXECUTOR_H
31 #include <jitter/jitter-executor.h>
32 
33 #ifdef JITTER_ENABLE_ASSEMBLY
34 #include <jitter/jitter-machine-common.h>
35 #include <jitter/machine/jitter-machine.h>
36 #endif // #ifdef JITTER_ENABLE_ASSEMBLY
37 #include <jitter/jitter-fatal.h>
38 #include <jitter/jitter-malloc.h>
39 
40 #include "jitterlispvm-vm.h"
41 //#include "jitterlispvm-meta-instructions.h"
42 //#include "jitterlispvm-specialized-instructions.h"
43 //#include "jitterlispvm-state.h"
44 
45 /* Include stack data structure support. */
46 #include <jitter/jitter-stack.h>
47 
48 /* Include patch-in definitions, only if patch-in is enabled.  We knoe whether it is
49    by checking JITTER_HAVE_PATCH_IN , defined in jitter/jitter-patch-in.h . */
50 #include <jitter/jitter-patch-in.h>
51 #ifdef JITTER_HAVE_PATCH_IN
52 # include <jitter/jitter-fast-branch.h>
53 
54   JITTER_DEFECT_DESCRIPTOR_DECLARATIONS_(jitterlispvm);
55   JITTER_PATCH_IN_DESCRIPTOR_DECLARATIONS_(jitterlispvm);
56 #endif // #ifdef JITTER_HAVE_PATCH_IN
57 
58 /* Always include fast-branch definitions, which use patch-ins where possible
59    or consist in fallback definitions otherwise. */
60 #include <jitter/jitter-fast-branch.h>
61 
62 #define JITTER_FAST_BRANCH_PREFIX jitterlispvm_
63 
64 /* Most of the needed macros are in jitter-executor.h .  This however
65    needs to be here, as it relies on a prefix to be substituted. */
66 #define JITTER_STATE_BACKING  \
67   (jitter_original_state->jitterlispvm_state_backing)
68 /* Expand to an l-value evaluating to the pending_notification field for
69    the current state. */
70 #define JITTER_PENDING_NOTIFICATIONS  \
71   (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA->pending_notifications)
72 /* Expand to an l-value evaluating to the pending field of the struct
73    jitter_signal_notification element for the given signal, for the
74    current state. */
75 #define JITTER_PENDING_SIGNAL_NOTIFICATION(signal_id)  \
76   ((JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA->pending_signal_notifications + (signal_id))->pending)
77 
78 /* Expand to the i-th fast register as an lvalue.  This is used internally,
79    always with a literal index . */
80 #define JITTER_FAST_REGISTER(class, index)                             \
81   (JITTER_CONCATENATE_FOUR(jitter_state_runtime.jitter_fast_register_, \
82                            class, _, index))
83 
84 /* Expand to a slow register lvalue, given an offset in bytes from the base. */
85 #define JITTER_SLOW_REGISTER_FROM_OFFSET(c, offset)               \
86   (* ((JITTER_CONCATENATE_TWO(jitterlispvm_register_, c) * restrict)  \
87       (((char *) jitter_array_base) + offset)))
88 
89 /* Expand to the i-th register, which must be a slow register, as an lvalue.
90    The given index must be a register index counting from 0 and including fast
91    regusters as well, if there are any.  For example if an r class had 3 fast
92    registers then the first slow register would be %r3, to be accessed as
93    JITTER_SLOW_REGISTER(r, 3).  It would be invalid to access %r0, %r1 and
94    %r2 which this macro, as %r0, %r1 and %r2 would be fast. */
95 #define JITTER_SLOW_REGISTER(c, i)                                          \
96   JITTER_SLOW_REGISTER_FROM_OFFSET(c, JITTERLISPVM_SLOW_REGISTER_OFFSET(c, i))
97 
98 /* It's not possible to have a single macro JITTER_REGISTER taking an index and
99    expanding to either a fast or a slow register lvalue, due to CPP conditional
100    limitations.  This restriction is unfortunate, but we have to live with it
101    as long as we don't switch to a different preprocessor.
102    What we can have is a set of zero-argument macros each expanding to a register
103    lvalue, for *a limited number* of registers.  Here we define access macros for
104    every fast register plus a reasonable number (currently 32) of slow registers,
105    per class. */
106 #define JITTER_REGISTER_r_0    JITTER_SLOW_REGISTER(r, 0)
107 #define JITTER_REGISTER_r_1    JITTER_SLOW_REGISTER(r, 1)
108 #define JITTER_REGISTER_r_2    JITTER_SLOW_REGISTER(r, 2)
109 #define JITTER_REGISTER_r_3    JITTER_SLOW_REGISTER(r, 3)
110 #define JITTER_REGISTER_r_4    JITTER_SLOW_REGISTER(r, 4)
111 #define JITTER_REGISTER_r_5    JITTER_SLOW_REGISTER(r, 5)
112 #define JITTER_REGISTER_r_6    JITTER_SLOW_REGISTER(r, 6)
113 #define JITTER_REGISTER_r_7    JITTER_SLOW_REGISTER(r, 7)
114 #define JITTER_REGISTER_r_8    JITTER_SLOW_REGISTER(r, 8)
115 #define JITTER_REGISTER_r_9    JITTER_SLOW_REGISTER(r, 9)
116 #define JITTER_REGISTER_r_10   JITTER_SLOW_REGISTER(r, 10)
117 #define JITTER_REGISTER_r_11   JITTER_SLOW_REGISTER(r, 11)
118 #define JITTER_REGISTER_r_12   JITTER_SLOW_REGISTER(r, 12)
119 #define JITTER_REGISTER_r_13   JITTER_SLOW_REGISTER(r, 13)
120 #define JITTER_REGISTER_r_14   JITTER_SLOW_REGISTER(r, 14)
121 #define JITTER_REGISTER_r_15   JITTER_SLOW_REGISTER(r, 15)
122 #define JITTER_REGISTER_r_16   JITTER_SLOW_REGISTER(r, 16)
123 #define JITTER_REGISTER_r_17   JITTER_SLOW_REGISTER(r, 17)
124 #define JITTER_REGISTER_r_18   JITTER_SLOW_REGISTER(r, 18)
125 #define JITTER_REGISTER_r_19   JITTER_SLOW_REGISTER(r, 19)
126 #define JITTER_REGISTER_r_20   JITTER_SLOW_REGISTER(r, 20)
127 #define JITTER_REGISTER_r_21   JITTER_SLOW_REGISTER(r, 21)
128 #define JITTER_REGISTER_r_22   JITTER_SLOW_REGISTER(r, 22)
129 #define JITTER_REGISTER_r_23   JITTER_SLOW_REGISTER(r, 23)
130 #define JITTER_REGISTER_r_24   JITTER_SLOW_REGISTER(r, 24)
131 #define JITTER_REGISTER_r_25   JITTER_SLOW_REGISTER(r, 25)
132 #define JITTER_REGISTER_r_26   JITTER_SLOW_REGISTER(r, 26)
133 #define JITTER_REGISTER_r_27   JITTER_SLOW_REGISTER(r, 27)
134 #define JITTER_REGISTER_r_28   JITTER_SLOW_REGISTER(r, 28)
135 #define JITTER_REGISTER_r_29   JITTER_SLOW_REGISTER(r, 29)
136 #define JITTER_REGISTER_r_30   JITTER_SLOW_REGISTER(r, 30)
137 #define JITTER_REGISTER_r_31   JITTER_SLOW_REGISTER(r, 31)
138 
139 
140 #ifdef JITTER_DISPATCH_NO_THREADING
141 
142 /* Reserve the scratch register, if any. */
143 #ifdef JITTER_SCRATCH_REGISTER
144   register union jitter_word
145   jitter_residual_argument_scratch_register_variable asm (JITTER_STRINGIFY(JITTER_SCRATCH_REGISTER));
146 #endif // #ifdef JITTER_SCRATCH_REGISTER
147 
148 /* Reserve The Array base register. */
149 #ifndef JITTER_BASE_REGISTER
150 # error "the machine does not define JITTER_BASE_REGISTER"
151 #else
152 register char * restrict
153 jitterlispvm_array_base_register_variable asm (JITTER_STRINGIFY(JITTER_BASE_REGISTER));
154 #endif // #ifndef JITTER_BASE_REGISTER
155 
156 /* Reserve registers for our 3 residual arguments.  If this particular VM doesn't
157    need all of those supported by the assembly machine then reserve only the first
158    ones.  If, on the other hand, we need more residual arguments than we have
159    available registers, use CPP macros to map the remaining residual arguments
160    to memory locations relative to the base, with constant offsets. */
161 
162 /* Define a macro for the 0-th residual as a register, or as a residual
163    memory slot.  Also define a macro expanding to inline asm code with
164    output constraints on the appropriate register or memory, to let GCC
165    know that its value has been changed by unknown code. */
166 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
167   register union jitter_word
168   jitter_residual_argument_0_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_0));
169 # define JITTER_RESIDUAL_ARGUMENT_0               \
170     jitter_residual_argument_0_register_variable
171 # define JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY                 \
172     JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_0_register_variable)
173 #else
174 # define JITTER_RESIDUAL_ARGUMENT_0  \
175     (* (union jitter_word *)                 \
176        (jitter_array_base + JITTERLISPVM_RESIDUAL_OFFSET(0)))
177 # define JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY                    \
178     JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_0)
179 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
180 
181 /* Define a macro for the 1-th residual as a register, or as a residual
182    memory slot.  Also define a macro expanding to inline asm code with
183    output constraints on the appropriate register or memory, to let GCC
184    know that its value has been changed by unknown code. */
185 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
186   register union jitter_word
187   jitter_residual_argument_1_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_1));
188 # define JITTER_RESIDUAL_ARGUMENT_1               \
189     jitter_residual_argument_1_register_variable
190 # define JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY                 \
191     JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_1_register_variable)
192 #else
193 # define JITTER_RESIDUAL_ARGUMENT_1  \
194     (* (union jitter_word *)                 \
195        (jitter_array_base + JITTERLISPVM_RESIDUAL_OFFSET(1)))
196 # define JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY                    \
197     JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_1)
198 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
199 
200 /* Define a macro for the 2-th residual as a register, or as a residual
201    memory slot.  Also define a macro expanding to inline asm code with
202    output constraints on the appropriate register or memory, to let GCC
203    know that its value has been changed by unknown code. */
204 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
205   register union jitter_word
206   jitter_residual_argument_2_register_variable asm (JITTER_STRINGIFY(JITTER_RESIDUAL_REGISTER_2));
207 # define JITTER_RESIDUAL_ARGUMENT_2               \
208     jitter_residual_argument_2_register_variable
209 # define JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY                 \
210     JITTER_MARK_REGISTER_AS_SET_BY_ASSEMBLY(jitter_residual_argument_2_register_variable)
211 #else
212 # define JITTER_RESIDUAL_ARGUMENT_2  \
213     (* (union jitter_word *)                 \
214        (jitter_array_base + JITTERLISPVM_RESIDUAL_OFFSET(2)))
215 # define JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY                    \
216     JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_RESIDUAL_ARGUMENT_2)
217 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
218 
219 /* The global register values we reserve in this compilation unit are
220    callee-save: the called function is supposed to save them before
221    setting them, and restore them to their previous value before
222    returning to the caller.  Of course this is not done automatically
223    in this compilation unit, so we have to do it by hand.  Notice that
224    every variable allocated to a register by GCC will not use the
225    registers we reserved, so we can be sure that, if we save our
226    global register variables before setting them for the first time,
227    their values will be the ones we want to retain. */
228 
229 /* The buffer where I keep the original register values needs to hold
230    every residual register, plus possibly the scratch register and the
231    residual base; those two registers are not always used, but allocating
232    just two words more costs essentially nothing and lets me simplify
233    the code a little.  The two words are not written or read unless
234    needed. */
235 #define JITTERLISPVM_REGISTER_BUFFER_ELEMENT_NO (JITTER_RESIDUAL_REGISTER_NO + 2)
236 __attribute__ ((noinline, cold))
237 
238 static void
jitterlispvm_save_registers(union jitter_word * buffer)239 jitterlispvm_save_registers (union jitter_word *buffer)
240 {
241   buffer [0].pointer = (union jitter_word*) jitterlispvm_array_base_register_variable;
242 #ifdef JITTER_SCRATCH_REGISTER
243   buffer [1] = jitter_residual_argument_scratch_register_variable;
244 #endif // #ifdef JITTER_SCRATCH_REGISTER
245 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
246   buffer [0 + 2] = JITTER_RESIDUAL_ARGUMENT_0;
247 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
248 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
249   buffer [1 + 2] = JITTER_RESIDUAL_ARGUMENT_1;
250 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
251 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
252   buffer [2 + 2] = JITTER_RESIDUAL_ARGUMENT_2;
253 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
254 }
255 
256 __attribute__ ((noinline, cold))
257 static void
jitterlispvm_restore_registers(const union jitter_word * buffer)258 jitterlispvm_restore_registers (const union jitter_word *buffer)
259 {
260   jitterlispvm_array_base_register_variable = (char *) buffer [0].pointer;
261 #ifdef JITTER_SCRATCH_REGISTER
262   jitter_residual_argument_scratch_register_variable = buffer [1];
263 #endif // #ifdef JITTER_SCRATCH_REGISTER
264 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
265   JITTER_RESIDUAL_ARGUMENT_0 = buffer [0 + 2];
266 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
267 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
268   JITTER_RESIDUAL_ARGUMENT_1 = buffer [1 + 2];
269 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
270 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
271   JITTER_RESIDUAL_ARGUMENT_2 = buffer [2 + 2];
272 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
273 }
274 
275 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
276 
277 
278 /* Wrapper definition of the top operation for the TOS-optimized stack "mainstack". */
279 #define JITTER_TOP_MAINSTACK()  \
280   JITTER_STACK_TOS_TOP(jitterlisp_object, jitter_state_runtime. , mainstack)
281 
282 /* Wrapper definition of the under_top operation for the TOS-optimized stack "mainstack". */
283 #define JITTER_UNDER_TOP_MAINSTACK()  \
284   JITTER_STACK_TOS_UNDER_TOP(jitterlisp_object, jitter_state_runtime. , mainstack)
285 
286 /* Wrapper definition of the at_depth operation for the TOS-optimized stack "mainstack". */
287 #define JITTER_AT_DEPTH_MAINSTACK(x0)  \
288   JITTER_STACK_TOS_AT_DEPTH(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
289 
290 /* Wrapper definition of the at_nonzero_depth operation for the TOS-optimized stack "mainstack". */
291 #define JITTER_AT_NONZERO_DEPTH_MAINSTACK(x0)  \
292   JITTER_STACK_TOS_AT_NONZERO_DEPTH(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
293 
294 /* Wrapper definition of the set_at_depth operation for the TOS-optimized stack "mainstack". */
295 #define JITTER_SET_AT_DEPTH_MAINSTACK(x0, x1)  \
296   JITTER_STACK_TOS_SET_AT_DEPTH(jitterlisp_object, jitter_state_runtime. , mainstack, x0, x1)
297 
298 /* Wrapper definition of the set_at_nonzero_depth operation for the TOS-optimized stack "mainstack". */
299 #define JITTER_SET_AT_NONZERO_DEPTH_MAINSTACK(x0, x1)  \
300   JITTER_STACK_TOS_SET_AT_NONZERO_DEPTH(jitterlisp_object, jitter_state_runtime. , mainstack, x0, x1)
301 
302 /* Wrapper definition of the push_unspecified operation for the TOS-optimized stack "mainstack". */
303 #define JITTER_PUSH_UNSPECIFIED_MAINSTACK()  \
304   JITTER_STACK_TOS_PUSH_UNSPECIFIED(jitterlisp_object, jitter_state_runtime. , mainstack)
305 
306 /* Wrapper definition of the push operation for the TOS-optimized stack "mainstack". */
307 #define JITTER_PUSH_MAINSTACK(x0)  \
308   JITTER_STACK_TOS_PUSH(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
309 
310 /* Wrapper definition of the drop operation for the TOS-optimized stack "mainstack". */
311 #define JITTER_DROP_MAINSTACK()  \
312   JITTER_STACK_TOS_DROP(jitterlisp_object, jitter_state_runtime. , mainstack)
313 
314 /* Wrapper definition of the dup operation for the TOS-optimized stack "mainstack". */
315 #define JITTER_DUP_MAINSTACK()  \
316   JITTER_STACK_TOS_DUP(jitterlisp_object, jitter_state_runtime. , mainstack)
317 
318 /* Wrapper definition of the swap operation for the TOS-optimized stack "mainstack". */
319 #define JITTER_SWAP_MAINSTACK()  \
320   JITTER_STACK_TOS_SWAP(jitterlisp_object, jitter_state_runtime. , mainstack)
321 
322 /* Wrapper definition of the quake operation for the TOS-optimized stack "mainstack". */
323 #define JITTER_QUAKE_MAINSTACK()  \
324   JITTER_STACK_TOS_QUAKE(jitterlisp_object, jitter_state_runtime. , mainstack)
325 
326 /* Wrapper definition of the over operation for the TOS-optimized stack "mainstack". */
327 #define JITTER_OVER_MAINSTACK()  \
328   JITTER_STACK_TOS_OVER(jitterlisp_object, jitter_state_runtime. , mainstack)
329 
330 /* Wrapper definition of the tuck operation for the TOS-optimized stack "mainstack". */
331 #define JITTER_TUCK_MAINSTACK()  \
332   JITTER_STACK_TOS_TUCK(jitterlisp_object, jitter_state_runtime. , mainstack)
333 
334 /* Wrapper definition of the nip operation for the TOS-optimized stack "mainstack". */
335 #define JITTER_NIP_MAINSTACK()  \
336   JITTER_STACK_TOS_NIP(jitterlisp_object, jitter_state_runtime. , mainstack)
337 
338 /* Wrapper definition of the rot operation for the TOS-optimized stack "mainstack". */
339 #define JITTER_ROT_MAINSTACK()  \
340   JITTER_STACK_TOS_ROT(jitterlisp_object, jitter_state_runtime. , mainstack)
341 
342 /* Wrapper definition of the mrot operation for the TOS-optimized stack "mainstack". */
343 #define JITTER_MROT_MAINSTACK()  \
344   JITTER_STACK_TOS_MROT(jitterlisp_object, jitter_state_runtime. , mainstack)
345 
346 /* Wrapper definition of the roll operation for the TOS-optimized stack "mainstack". */
347 #define JITTER_ROLL_MAINSTACK(x0)  \
348   JITTER_STACK_TOS_ROLL(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
349 
350 /* Wrapper definition of the mroll operation for the TOS-optimized stack "mainstack". */
351 #define JITTER_MROLL_MAINSTACK(x0)  \
352   JITTER_STACK_TOS_MROLL(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
353 
354 /* Wrapper definition of the slide operation for the TOS-optimized stack "mainstack". */
355 #define JITTER_SLIDE_MAINSTACK(x0, x1)  \
356   JITTER_STACK_TOS_SLIDE(jitterlisp_object, jitter_state_runtime. , mainstack, x0, x1)
357 
358 /* Wrapper definition of the whirl operation for the TOS-optimized stack "mainstack". */
359 #define JITTER_WHIRL_MAINSTACK(x0)  \
360   JITTER_STACK_TOS_WHIRL(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
361 
362 /* Wrapper definition of the bulge operation for the TOS-optimized stack "mainstack". */
363 #define JITTER_BULGE_MAINSTACK(x0)  \
364   JITTER_STACK_TOS_BULGE(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
365 
366 /* Wrapper definition of the height operation for the TOS-optimized stack "mainstack". */
367 #define JITTER_HEIGHT_MAINSTACK()  \
368   JITTER_STACK_TOS_HEIGHT(jitterlisp_object, jitter_state_runtime. , mainstack)
369 
370 /* Wrapper definition of the set_height operation for the TOS-optimized stack "mainstack". */
371 #define JITTER_SET_HEIGHT_MAINSTACK(x0)  \
372   JITTER_STACK_TOS_SET_HEIGHT(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
373 
374 /* Wrapper definition of the reverse operation for the TOS-optimized stack "mainstack". */
375 #define JITTER_REVERSE_MAINSTACK(x0)  \
376   JITTER_STACK_TOS_REVERSE(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
377 
378 /* Wrapper definition of the unary operation for the TOS-optimized stack "mainstack". */
379 #define JITTER_UNARY_MAINSTACK(x0)  \
380   JITTER_STACK_TOS_UNARY(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
381 
382 /* Wrapper definition of the binary operation for the TOS-optimized stack "mainstack". */
383 #define JITTER_BINARY_MAINSTACK(x0)  \
384   JITTER_STACK_TOS_BINARY(jitterlisp_object, jitter_state_runtime. , mainstack, x0)
385 
386 /* Wrapper definition of the top operation for the non-TOS-optimized stack "returnstack". */
387 #define JITTER_TOP_RETURNSTACK()  \
388   JITTER_STACK_NTOS_TOP(jitterlisp_object, jitter_state_runtime. , returnstack)
389 
390 /* Wrapper definition of the under_top operation for the non-TOS-optimized stack "returnstack". */
391 #define JITTER_UNDER_TOP_RETURNSTACK()  \
392   JITTER_STACK_NTOS_UNDER_TOP(jitterlisp_object, jitter_state_runtime. , returnstack)
393 
394 /* Wrapper definition of the at_depth operation for the non-TOS-optimized stack "returnstack". */
395 #define JITTER_AT_DEPTH_RETURNSTACK(x0)  \
396   JITTER_STACK_NTOS_AT_DEPTH(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
397 
398 /* Wrapper definition of the at_nonzero_depth operation for the non-TOS-optimized stack "returnstack". */
399 #define JITTER_AT_NONZERO_DEPTH_RETURNSTACK(x0)  \
400   JITTER_STACK_NTOS_AT_NONZERO_DEPTH(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
401 
402 /* Wrapper definition of the set_at_depth operation for the non-TOS-optimized stack "returnstack". */
403 #define JITTER_SET_AT_DEPTH_RETURNSTACK(x0, x1)  \
404   JITTER_STACK_NTOS_SET_AT_DEPTH(jitterlisp_object, jitter_state_runtime. , returnstack, x0, x1)
405 
406 /* Wrapper definition of the set_at_nonzero_depth operation for the non-TOS-optimized stack "returnstack". */
407 #define JITTER_SET_AT_NONZERO_DEPTH_RETURNSTACK(x0, x1)  \
408   JITTER_STACK_NTOS_SET_AT_NONZERO_DEPTH(jitterlisp_object, jitter_state_runtime. , returnstack, x0, x1)
409 
410 /* Wrapper definition of the push_unspecified operation for the non-TOS-optimized stack "returnstack". */
411 #define JITTER_PUSH_UNSPECIFIED_RETURNSTACK()  \
412   JITTER_STACK_NTOS_PUSH_UNSPECIFIED(jitterlisp_object, jitter_state_runtime. , returnstack)
413 
414 /* Wrapper definition of the push operation for the non-TOS-optimized stack "returnstack". */
415 #define JITTER_PUSH_RETURNSTACK(x0)  \
416   JITTER_STACK_NTOS_PUSH(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
417 
418 /* Wrapper definition of the drop operation for the non-TOS-optimized stack "returnstack". */
419 #define JITTER_DROP_RETURNSTACK()  \
420   JITTER_STACK_NTOS_DROP(jitterlisp_object, jitter_state_runtime. , returnstack)
421 
422 /* Wrapper definition of the dup operation for the non-TOS-optimized stack "returnstack". */
423 #define JITTER_DUP_RETURNSTACK()  \
424   JITTER_STACK_NTOS_DUP(jitterlisp_object, jitter_state_runtime. , returnstack)
425 
426 /* Wrapper definition of the swap operation for the non-TOS-optimized stack "returnstack". */
427 #define JITTER_SWAP_RETURNSTACK()  \
428   JITTER_STACK_NTOS_SWAP(jitterlisp_object, jitter_state_runtime. , returnstack)
429 
430 /* Wrapper definition of the quake operation for the non-TOS-optimized stack "returnstack". */
431 #define JITTER_QUAKE_RETURNSTACK()  \
432   JITTER_STACK_NTOS_QUAKE(jitterlisp_object, jitter_state_runtime. , returnstack)
433 
434 /* Wrapper definition of the over operation for the non-TOS-optimized stack "returnstack". */
435 #define JITTER_OVER_RETURNSTACK()  \
436   JITTER_STACK_NTOS_OVER(jitterlisp_object, jitter_state_runtime. , returnstack)
437 
438 /* Wrapper definition of the tuck operation for the non-TOS-optimized stack "returnstack". */
439 #define JITTER_TUCK_RETURNSTACK()  \
440   JITTER_STACK_NTOS_TUCK(jitterlisp_object, jitter_state_runtime. , returnstack)
441 
442 /* Wrapper definition of the nip operation for the non-TOS-optimized stack "returnstack". */
443 #define JITTER_NIP_RETURNSTACK()  \
444   JITTER_STACK_NTOS_NIP(jitterlisp_object, jitter_state_runtime. , returnstack)
445 
446 /* Wrapper definition of the rot operation for the non-TOS-optimized stack "returnstack". */
447 #define JITTER_ROT_RETURNSTACK()  \
448   JITTER_STACK_NTOS_ROT(jitterlisp_object, jitter_state_runtime. , returnstack)
449 
450 /* Wrapper definition of the mrot operation for the non-TOS-optimized stack "returnstack". */
451 #define JITTER_MROT_RETURNSTACK()  \
452   JITTER_STACK_NTOS_MROT(jitterlisp_object, jitter_state_runtime. , returnstack)
453 
454 /* Wrapper definition of the roll operation for the non-TOS-optimized stack "returnstack". */
455 #define JITTER_ROLL_RETURNSTACK(x0)  \
456   JITTER_STACK_NTOS_ROLL(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
457 
458 /* Wrapper definition of the mroll operation for the non-TOS-optimized stack "returnstack". */
459 #define JITTER_MROLL_RETURNSTACK(x0)  \
460   JITTER_STACK_NTOS_MROLL(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
461 
462 /* Wrapper definition of the slide operation for the non-TOS-optimized stack "returnstack". */
463 #define JITTER_SLIDE_RETURNSTACK(x0, x1)  \
464   JITTER_STACK_NTOS_SLIDE(jitterlisp_object, jitter_state_runtime. , returnstack, x0, x1)
465 
466 /* Wrapper definition of the whirl operation for the non-TOS-optimized stack "returnstack". */
467 #define JITTER_WHIRL_RETURNSTACK(x0)  \
468   JITTER_STACK_NTOS_WHIRL(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
469 
470 /* Wrapper definition of the bulge operation for the non-TOS-optimized stack "returnstack". */
471 #define JITTER_BULGE_RETURNSTACK(x0)  \
472   JITTER_STACK_NTOS_BULGE(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
473 
474 /* Wrapper definition of the height operation for the non-TOS-optimized stack "returnstack". */
475 #define JITTER_HEIGHT_RETURNSTACK()  \
476   JITTER_STACK_NTOS_HEIGHT(jitterlisp_object, jitter_state_runtime. , returnstack)
477 
478 /* Wrapper definition of the set_height operation for the non-TOS-optimized stack "returnstack". */
479 #define JITTER_SET_HEIGHT_RETURNSTACK(x0)  \
480   JITTER_STACK_NTOS_SET_HEIGHT(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
481 
482 /* Wrapper definition of the reverse operation for the non-TOS-optimized stack "returnstack". */
483 #define JITTER_REVERSE_RETURNSTACK(x0)  \
484   JITTER_STACK_NTOS_REVERSE(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
485 
486 /* Wrapper definition of the unary operation for the non-TOS-optimized stack "returnstack". */
487 #define JITTER_UNARY_RETURNSTACK(x0)  \
488   JITTER_STACK_NTOS_UNARY(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
489 
490 /* Wrapper definition of the binary operation for the non-TOS-optimized stack "returnstack". */
491 #define JITTER_BINARY_RETURNSTACK(x0)  \
492   JITTER_STACK_NTOS_BINARY(jitterlisp_object, jitter_state_runtime. , returnstack, x0)
493 
494 /* Late C code from the user. */
495 
496 __attribute__ ((unused))
497 void
debug_pointer(jitter_int index,const void * pointer)498 debug_pointer (jitter_int index, const void *pointer)
499 {
500   return;
501   printf ("[DEBUG: %lli %p]\n", (long long) index, pointer);
502   fflush (stdout);
503 }
504 
505 /* Open an argument-type-checking sequence, for the given number of arguments
506    to be read from the main stack.  This is a helper macro for
507    JITTERLISPVM_CHECK_TYPES_* . */
508 #define JITTERLISPVM_BEGIN_CHECK_TYPES_(_jitterlisp_vm_in_arity)  \
509   JITTER_BEGIN_                                                   \
510     int _jitterlispvm_arg_no = (_jitterlisp_vm_in_arity);         \
511     int _jitterlispvm_arg_index __attribute__ ((unused)) = 0;     \
512     int _jitterlispvm_arg_depth __attribute__ ((unused)) \
513       = _jitterlispvm_arg_no - 1;
514 
515 /* Check the next argument in the sequence, failing if its type doesn't match
516    the given uppercase suffix.  Do nothing if compiling an unsafe JitterLisp. */
517 #ifdef JITTERLISP_UNSAFE
518 # define JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type,    \
519                                        _jitterlisp_error_fast_label)  \
520     { /* Do nothing. */ }
521 #else
522 # define JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type,     \
523                                        _jitterlisp_error_fast_label)   \
524     {                                                                  \
525       /* Branch-fast to the given label if the next object type is     \
526          not the required one. */                                      \
527       JITTER_CONCATENATE_TWO (JITTERLISP_BRANCH_FAST_UNLESS_,          \
528                               _jitterlisp_uppercase_type)              \
529          (JITTER_AT_DEPTH_MAINSTACK(_jitterlispvm_arg_depth),          \
530           _jitterlisp_error_fast_label);                               \
531       _jitterlispvm_arg_depth --;                                      \
532       _jitterlispvm_arg_index ++;                                      \
533     }
534 #endif // #ifdef JITTERLISP_UNSAFE
535 
536 /* Close an argument-type-checking sequence.  This is a helper macro for
537    JITTERLISPVM_CHECK_TYPES_* . */
538 #define JITTERLISPVM_END_CHECK_TYPES_  \
539   JITTER_END_
540 
541 /* For in-arity N, check that the topmost N arguments have the given N types
542    expressed as uppercase suffixes, respectively.  This functionality is
543    provided for a few common values of N . */
544 #define JITTERLISPVM_CHECK_TYPES_1(_jitterlisp_uppercase_type_0,  \
545                                    _jitterlisp_error_fast_label)  \
546   JITTERLISPVM_BEGIN_CHECK_TYPES_(1)                              \
547     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
548                                   _jitterlisp_error_fast_label);  \
549   JITTERLISPVM_END_CHECK_TYPES_
550 #define JITTERLISPVM_CHECK_TYPES_2(_jitterlisp_uppercase_type_0,  \
551                                    _jitterlisp_uppercase_type_1,  \
552                                    _jitterlisp_error_fast_label)  \
553   JITTERLISPVM_BEGIN_CHECK_TYPES_(2)                              \
554     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
555                                   _jitterlisp_error_fast_label);  \
556     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_1,   \
557                                   _jitterlisp_error_fast_label);  \
558   JITTERLISPVM_END_CHECK_TYPES_
559 #define JITTERLISPVM_CHECK_TYPES_3(_jitterlisp_uppercase_type_0,  \
560                                    _jitterlisp_uppercase_type_1,  \
561                                    _jitterlisp_uppercase_type_2,  \
562                                    _jitterlisp_error_fast_label)  \
563   JITTERLISPVM_BEGIN_CHECK_TYPES_(3)                              \
564     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
565                                   _jitterlisp_error_fast_label);  \
566     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_1,   \
567                                   _jitterlisp_error_fast_label);  \
568     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_2,   \
569                                   _jitterlisp_error_fast_label);  \
570   JITTERLISPVM_END_CHECK_TYPES_
571 #define JITTERLISPVM_CHECK_TYPES_4(_jitterlisp_uppercase_type_0,  \
572                                    _jitterlisp_uppercase_type_1,  \
573                                    _jitterlisp_uppercase_type_2,  \
574                                    _jitterlisp_uppercase_type_3,  \
575                                    _jitterlisp_error_fast_label)  \
576   JITTERLISPVM_BEGIN_CHECK_TYPES_(4)                              \
577     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_0,   \
578                                   _jitterlisp_error_fast_label);  \
579     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_1,   \
580                                   _jitterlisp_error_fast_label);  \
581     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_2,   \
582                                   _jitterlisp_error_fast_label);  \
583     JITTERLISPVM_CHECK_NEXT_TYPE_(_jitterlisp_uppercase_type_3,   \
584                                   _jitterlisp_error_fast_label);  \
585   JITTERLISPVM_END_CHECK_TYPES_
586 
587 #if 0
588 # define JITTERLISPVM_ERROR_INVALID_PRIMITIVE_ARGUMENT_TYPE_          \
589     jitterlispvm_error_invalid_primitive_argument_type_unfriendly ()
590 #else
591 # define JITTERLISPVM_ERROR_INVALID_PRIMITIVE_ARGUMENT_TYPE_     \
592     jitterlispvm_error_invalid_primitive_argument_type_friendly  \
593        (JITTER_SPECIALIZED_INSTRUCTION_OPCODE,                   \
594         _jitterlispvm_arg_index,                                 \
595         JITTER_AT_DEPTH_MAINSTACK(_jitterlispvm_arg_depth))
596 #endif
597 
598 
599 // Unfortunately the attribute is invisible across the wrapper.
600 // This is convenient for debugging, but I don't want to use it in production:
601 // passing parameters at every call makes the code much bigger, even if the
602 // call is not executed.
603 __attribute__ ((noreturn, unused))
604 static void
jitterlispvm_error_invalid_primitive_argument_type_friendly(int sins_opcode,int arg_index,jitterlisp_object o)605 jitterlispvm_error_invalid_primitive_argument_type_friendly
606    (int sins_opcode,
607     int arg_index,
608     jitterlisp_object o)
609 {
610   /* Print information about the argument and its hex representation:
611      don't dare yet to print it as a Lisp object, as the printer might
612      crash if there is a bug and the object is invalid. */
613   char buffer [1000];
614   printf (buffer,
615           "%s: About the %i-th (0-based) primitive argument %p\n",
616           jitterlispvm_specialized_instruction_names [sins_opcode],
617           arg_index, (void *) o);
618   jitterlisp_print_error_char_star (buffer);
619 
620   /* This shouldn't be needed on GNU, but flush the output so that we can be
621      sure that the previous line is visible before we crash. */
622   jitter_print_flush (jitterlisp_print_context);
623 
624   /* Okay, now we can print in in Lisp. */
625   jitterlisp_print_error_char_star ("  (in Lisp ");
626   jitterlisp_print_error (o);
627   jitterlisp_print_error_char_star ("):\n");
628 
629   jitterlisp_error_cloned ("invalid primitive argument type");
630 }
631 
632 __attribute__ ((noreturn, unused))
633 static void
jitterlispvm_error_invalid_primitive_argument_type_unfriendly(void)634 jitterlispvm_error_invalid_primitive_argument_type_unfriendly (void)
635 {
636   jitterlisp_error_cloned ("invalid primitive argument type");
637 }
638 
639 static void
jitterlisp_fail_from_vm(void)640 jitterlisp_fail_from_vm (void)
641 {
642   jitterlisp_error_cloned ("unspecified error raised by VM code");
643 }
644 
645     static const char *stack_printf_format_string __attribute__ ((unused))
646       = "%" JITTER_PRIi "\n";
647 
648 
649   /* End of the late C code from the user. */
650 
651 /* The definition of this is machine-generated in jitterlispvm-vm2.c , and the
652    function is not intended for the user.  If initializing then set
653    structuredvm_threads and structuredvm_thread_sizes and just return, ignoring
654    the other fieldsp and s.  If not initializing then actually enter VM code
655    starting from the given program point in the pointed state. */
656 static void
657 jitterlispvm_execute_or_initialize (bool jitter_initialize,
658                                 jitterlispvm_program_point jitter_initial_program_point,
659                                 struct jitterlispvm_state * const jitter_original_state)
660   __attribute__ ((noclone, noinline));
661 
662 void
jitterlispvm_execute_executable_routine(const struct jitter_executable_routine * er,struct jitterlispvm_state * s)663 jitterlispvm_execute_executable_routine (const struct jitter_executable_routine *er,
664                                      struct jitterlispvm_state *s)
665 {
666   jitterlispvm_make_place_for_slow_registers (s, er->slow_register_per_class_no);
667   jitter_program_point initial_program_point
668     = JITTERLISPVM_EXECUTABLE_ROUTINE_BEGINNING (er);
669   jitterlispvm_execute_or_initialize (false, initial_program_point, s);
670 }
671 
672 
673 /* Threads or pointers to native code blocks of course don't exist with
674    switch-dispatching. */
675 #ifndef JITTER_DISPATCH_SWITCH
676 const jitter_thread *
677 jitterlispvm_threads;
678 
679 const jitter_thread *
680 jitterlispvm_thread_ends;
681 
682 const long *
683 jitterlispvm_thread_sizes;
684 #endif // #ifndef JITTER_DISPATCH_SWITCH
685 
686 void
jitterlispvm_initialize_threads(void)687 jitterlispvm_initialize_threads (void)
688 {
689   jitterlispvm_execute_or_initialize (true, NULL, NULL);
690 }
691 
692 void
jitterlispvm_branch_to_program_point(jitterlispvm_program_point p,struct jitterlispvm_state * s)693 jitterlispvm_branch_to_program_point (jitterlispvm_program_point p, struct jitterlispvm_state *s)
694 {
695   jitterlispvm_execute_or_initialize (false, p, s);
696 }
697 
698 static void
jitterlispvm_execute_or_initialize(bool jitter_initialize,jitterlispvm_program_point jitter_initial_program_point,struct jitterlispvm_state * const jitter_original_state)699 jitterlispvm_execute_or_initialize (bool jitter_initialize,
700                                 jitterlispvm_program_point jitter_initial_program_point,
701                                 struct jitterlispvm_state * const jitter_original_state)
702 {
703 #ifdef JITTER_DISPATCH_NO_THREADING
704   /* Save the values in the registers we reserved as global variables,
705      since from the point of view of the other C compilation units such
706      registers are callee-save.  FIXME: this is not really needed when
707      initializing, if I've been careful; but for the time being I want
708      to play it safe. */
709   union jitter_word jitter_register_buffer [JITTERLISPVM_REGISTER_BUFFER_ELEMENT_NO];
710   jitterlispvm_save_registers (jitter_register_buffer);
711 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
712 
713 #ifdef JITTER_HAVE_PATCH_IN
714   /* Generate the single patch-in header for this executor as a
715      global asm statement.  This expands into a global definition in
716      assembly in a separate subsection, and relies on toplevel C
717      definitions not being reordered: jitterlispvm_execute_or_initialize
718      will add to the same global.  Do the same for defects. */
719   JITTER_DEFECT_HEADER(jitterlispvm);
720   JITTER_PATCH_IN_HEADER(jitterlispvm);
721 #endif // #ifdef JITTER_HAVE_PATCH_IN
722 
723 #ifndef JITTER_DISPATCH_SWITCH
724   JITTER_DATA_LOCATION_HEADER(jitterlispvm);
725 #endif // #ifndef JITTER_DISPATCH_SWITCH
726 
727   /* Initialization.  This is only called once at startup. */
728   if (__builtin_expect (jitter_initialize, false))
729     {
730       /* Make sure that vm1 and vm2 were macroexpanded consistently
731          with respect to instrumentation macros.  This relies on the
732          enum values for each feature working as individual bits in a
733          bitmask: see the comment in jitter/jitter-vm.h . */
734       enum jitter_vm_instrumentation correct_instrumentation
735         = jitter_vm_instrumentation_none;
736 #if defined (JITTER_PROFILE_COUNT)
737       correct_instrumentation |= jitter_vm_instrumentation_count;
738 #endif
739 #if defined (JITTER_PROFILE_SAMPLE)
740       correct_instrumentation |= jitter_vm_instrumentation_sample;
741 #endif
742       if (jitterlispvm_vm_configuration->instrumentation != correct_instrumentation)
743         jitter_fatal ("vm1 and vm2 were compiled with different profiling "
744                       "instrumentation macros.  Please recompile with coherent "
745                       "CPPFLAGS");
746 
747 #if defined (JITTER_PROFILE_SAMPLE)
748     /* Initialise the sample-profile subsystem, once and for all. */
749     jitterlispvm_profile_sample_initialize ();
750 #endif // #if defined (JITTER_PROFILE_SAMPLE)
751 
752 #ifndef JITTER_DISPATCH_SWITCH
753       /* FIXME: I can do this with only one relocation, by keeping
754          a pointer to the first VM instruction beginning in a static
755          variable, and then having a static vector of offsets with
756          respect to the first pointer.  This will slightly complicate
757          my initialization code, but should make startup faster.
758          FIXME: that won't work on AVR, according to the GCC
759          documentation.  Do I care?  Probably not, since AVRs can't
760          address more than 2^16 bytes, which is too little to run my
761          VMs. */
762       static const jitter_thread jitterlispvm_the_threads []
763         = {
764             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID),
765             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eBEGINBASICBLOCK),
766             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eEXITVM),
767             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eDATALOCATIONS),
768             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eNOP),
769             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE0),
770             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE1),
771             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE2),
772             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n1___rrR),
773             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n2___rrR),
774             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n3___rrR),
775             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n4___rrR),
776             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n5___rrR),
777             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n6___rrR),
778             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n7___rrR),
779             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n8___rrR),
780             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n9___rrR),
781             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n10___rrR),
782             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__nR___rrR),
783             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch__fR),
784             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mfalse__fR),
785             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mless__fR__fR),
786             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mnull__fR),
787             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnull__fR),
788             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mnon_mzero___rrR__fR__fR),
789             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mtrue__fR),
790             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n0__retR),
791             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n1__retR),
792             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n2__retR),
793             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n3__retR),
794             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n4__retR),
795             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n5__retR),
796             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n6__retR),
797             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n7__retR),
798             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n8__retR),
799             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n9__retR),
800             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n10__retR),
801             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__nR__retR),
802             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n0__retR),
803             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n1__retR),
804             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n2__retR),
805             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n3__retR),
806             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n4__retR),
807             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n5__retR),
808             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n6__retR),
809             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n7__retR),
810             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n8__retR),
811             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n9__retR),
812             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n10__retR),
813             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__nR__retR),
814             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mfrom_mc__retR),
815             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(canonicalize_mboolean),
816             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mclosure__fR),
817             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mglobal_mdefined__nR__fR),
818             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n0__fR),
819             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n1__fR),
820             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n2__fR),
821             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n3__fR),
822             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n4__fR),
823             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n5__fR),
824             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n6__fR),
825             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n7__fR),
826             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n8__fR),
827             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n9__fR),
828             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n10__fR),
829             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__nR__fR),
830             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n0__fR),
831             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n1__fR),
832             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n2__fR),
833             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n3__fR),
834             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n4__fR),
835             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n5__fR),
836             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n6__fR),
837             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n7__fR),
838             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n8__fR),
839             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n9__fR),
840             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n10__fR),
841             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__nR__fR),
842             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mliteral__nR),
843             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mregister___rrR),
844             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mto_mregister___rrR),
845             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop),
846             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop_mnip),
847             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(dup),
848             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exitvm),
849             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(fail__retR),
850             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gc_mif_mneeded__fR),
851             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n4),
852             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n8),
853             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n12),
854             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n16),
855             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n24),
856             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n32),
857             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n36),
858             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n48),
859             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n52),
860             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n64),
861             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__nR),
862             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(literal_mto_mregister__nR___rrR),
863             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip),
864             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mdrop),
865             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive),
866             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive_mdrop),
867             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour),
868             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour_mdrop),
869             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mliteral__nR),
870             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mregister___rrR),
871             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix),
872             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix_mdrop),
873             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree),
874             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree_mdrop),
875             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo),
876             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo_mdrop),
877             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nop),
878             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal__nR__fR),
879             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal_mdefined__nR__fR),
880             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mregister___rrR),
881             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n0__fR),
882             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n1__fR),
883             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n2__fR),
884             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n3__fR),
885             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n4__fR),
886             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__nR__fR),
887             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mboolean_mcanonicalize),
888             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox),
889             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_mget__fR),
890             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_msetb_mspecial__fR),
891             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcar__fR),
892             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcdr__fR),
893             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcharacterp),
894             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcons_mspecial),
895             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mconsp),
896             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_meqp),
897             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_meqp__fR),
898             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_mnot_meqp__fR),
899             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnump),
900             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mgreaterp__fR),
901             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mlessp__fR),
902             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegate__fR),
903             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegativep__fR),
904             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mconsp),
905             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnegativep__fR),
906             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnullp),
907             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mpositivep__fR),
908             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_msymbolp),
909             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mzerop__fR),
910             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot),
911             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_meqp),
912             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mgreaterp__fR),
913             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mlessp__fR),
914             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnothingp),
915             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnullp),
916             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mminus__fR),
917             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mplus__fR),
918             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mpositivep__fR),
919             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided__fR),
920             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided_munsafe__fR),
921             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mminus__fR),
922             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mplus__fR),
923             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mtimes__fR),
924             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient__fR),
925             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient_munsafe__fR),
926             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder__fR),
927             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder_munsafe__fR),
928             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcarb_mspecial__fR),
929             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcdrb_mspecial__fR),
930             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_msymbolp),
931             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mdivided__fR),
932             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mquotient__fR),
933             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mremainder__fR),
934             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mtimes__fR),
935             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_muniquep),
936             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mzerop__fR),
937             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(procedure_mprolog),
938             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mfalse),
939             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mglobal__nR__fR),
940             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mliteral__nR),
941             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnil),
942             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnothing),
943             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mone),
944             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mregister___rrR),
945             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_munspecified),
946             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mzero),
947             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(register_mto_mregister___rrR___rrR),
948             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(restore_mregister___rrR),
949             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(return),
950             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(save_mregister___rrR),
951             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n0),
952             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n1),
953             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n2),
954             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n3),
955             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n4),
956             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n5),
957             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n6),
958             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n7),
959             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n8),
960             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n9),
961             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n10),
962             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__nR),
963             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n0),
964             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n1),
965             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n2),
966             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n3),
967             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n4),
968             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n5),
969             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n6),
970             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n7),
971             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n8),
972             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n9),
973             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n10),
974             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__nR),
975             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unreachable),
976             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch__fR_A_mno_mfast_mbranches),
977             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches),
978             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches),
979             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches),
980             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches),
981             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches),
982             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches),
983             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches),
984             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches),
985             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches),
986             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches),
987             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches),
988             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches),
989             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches),
990             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches),
991             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches),
992             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches),
993             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches),
994             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches),
995             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches),
996             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches),
997             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches),
998             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches),
999             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches),
1000             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches),
1001             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches),
1002             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches),
1003             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches),
1004             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches),
1005             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches),
1006             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches),
1007             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches),
1008             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches),
1009             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches),
1010             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches),
1011             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches),
1012             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches),
1013             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches),
1014             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches),
1015             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches),
1016             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches),
1017             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches),
1018             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches),
1019             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches),
1020             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches),
1021             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches),
1022             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches),
1023             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches),
1024             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches),
1025             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches),
1026             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches),
1027             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches),
1028             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches),
1029             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches),
1030             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches),
1031             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches),
1032             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches),
1033             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches),
1034             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches),
1035             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches),
1036             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches),
1037             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches),
1038             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches),
1039             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches),
1040             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches),
1041             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches),
1042             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches),
1043             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches),
1044             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches),
1045             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches),
1046             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches),
1047             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches),
1048             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches),
1049             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches),
1050             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches),
1051             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches),
1052             && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches)
1053           };
1054       static const jitter_thread jitterlispvm_the_thread_ends []
1055         = {
1056             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eINVALID),
1057             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eBEGINBASICBLOCK),
1058             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eEXITVM),
1059             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eDATALOCATIONS),
1060             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eNOP),
1061             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE0),
1062             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE1),
1063             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE2),
1064             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n1___rrR),
1065             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n2___rrR),
1066             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n3___rrR),
1067             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n4___rrR),
1068             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n5___rrR),
1069             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n6___rrR),
1070             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n7___rrR),
1071             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n8___rrR),
1072             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n9___rrR),
1073             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n10___rrR),
1074             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__nR___rrR),
1075             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch__fR),
1076             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mfalse__fR),
1077             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnot_mless__fR__fR),
1078             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnot_mnull__fR),
1079             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnull__fR),
1080             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mregister_mnon_mzero___rrR__fR__fR),
1081             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mtrue__fR),
1082             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n0__retR),
1083             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n1__retR),
1084             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n2__retR),
1085             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n3__retR),
1086             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n4__retR),
1087             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n5__retR),
1088             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n6__retR),
1089             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n7__retR),
1090             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n8__retR),
1091             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n9__retR),
1092             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n10__retR),
1093             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__nR__retR),
1094             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n0__retR),
1095             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n1__retR),
1096             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n2__retR),
1097             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n3__retR),
1098             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n4__retR),
1099             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n5__retR),
1100             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n6__retR),
1101             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n7__retR),
1102             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n8__retR),
1103             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n9__retR),
1104             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n10__retR),
1105             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__nR__retR),
1106             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mfrom_mc__retR),
1107             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(canonicalize_mboolean),
1108             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_mclosure__fR),
1109             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_mglobal_mdefined__nR__fR),
1110             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n0__fR),
1111             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n1__fR),
1112             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n2__fR),
1113             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n3__fR),
1114             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n4__fR),
1115             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n5__fR),
1116             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n6__fR),
1117             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n7__fR),
1118             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n8__fR),
1119             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n9__fR),
1120             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n10__fR),
1121             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__nR__fR),
1122             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n0__fR),
1123             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n1__fR),
1124             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n2__fR),
1125             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n3__fR),
1126             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n4__fR),
1127             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n5__fR),
1128             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n6__fR),
1129             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n7__fR),
1130             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n8__fR),
1131             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n9__fR),
1132             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n10__fR),
1133             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__nR__fR),
1134             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mfrom_mliteral__nR),
1135             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mfrom_mregister___rrR),
1136             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mto_mregister___rrR),
1137             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop),
1138             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop_mnip),
1139             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(dup),
1140             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(exitvm),
1141             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(fail__retR),
1142             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gc_mif_mneeded__fR),
1143             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n4),
1144             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n8),
1145             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n12),
1146             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n16),
1147             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n24),
1148             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n32),
1149             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n36),
1150             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n48),
1151             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n52),
1152             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n64),
1153             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__nR),
1154             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(literal_mto_mregister__nR___rrR),
1155             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip),
1156             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mdrop),
1157             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfive),
1158             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfive_mdrop),
1159             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfour),
1160             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfour_mdrop),
1161             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mpush_mliteral__nR),
1162             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mpush_mregister___rrR),
1163             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_msix),
1164             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_msix_mdrop),
1165             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mthree),
1166             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mthree_mdrop),
1167             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mtwo),
1168             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mtwo_mdrop),
1169             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nop),
1170             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mglobal__nR__fR),
1171             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mglobal_mdefined__nR__fR),
1172             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mregister___rrR),
1173             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n0__fR),
1174             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n1__fR),
1175             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n2__fR),
1176             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n3__fR),
1177             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n4__fR),
1178             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__nR__fR),
1179             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mboolean_mcanonicalize),
1180             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox),
1181             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox_mget__fR),
1182             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox_msetb_mspecial__fR),
1183             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcar__fR),
1184             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcdr__fR),
1185             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcharacterp),
1186             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcons_mspecial),
1187             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mconsp),
1188             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_meqp),
1189             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnum_meqp__fR),
1190             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnum_mnot_meqp__fR),
1191             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnump),
1192             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mgreaterp__fR),
1193             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mlessp__fR),
1194             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnegate__fR),
1195             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnegativep__fR),
1196             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mconsp),
1197             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mnegativep__fR),
1198             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mnullp),
1199             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mpositivep__fR),
1200             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_msymbolp),
1201             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mzerop__fR),
1202             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot),
1203             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_meqp),
1204             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_mgreaterp__fR),
1205             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_mlessp__fR),
1206             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnothingp),
1207             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnullp),
1208             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mone_mminus__fR),
1209             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mone_mplus__fR),
1210             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mpositivep__fR),
1211             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mdivided__fR),
1212             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mdivided_munsafe__fR),
1213             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mminus__fR),
1214             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mplus__fR),
1215             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mtimes__fR),
1216             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mquotient__fR),
1217             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mquotient_munsafe__fR),
1218             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mremainder__fR),
1219             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mremainder_munsafe__fR),
1220             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mset_mcarb_mspecial__fR),
1221             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mset_mcdrb_mspecial__fR),
1222             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_msymbolp),
1223             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mdivided__fR),
1224             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mquotient__fR),
1225             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mremainder__fR),
1226             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mtimes__fR),
1227             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_muniquep),
1228             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mzerop__fR),
1229             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(procedure_mprolog),
1230             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mfalse),
1231             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mglobal__nR__fR),
1232             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mliteral__nR),
1233             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mnil),
1234             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mnothing),
1235             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mone),
1236             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mregister___rrR),
1237             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_munspecified),
1238             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mzero),
1239             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(register_mto_mregister___rrR___rrR),
1240             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(restore_mregister___rrR),
1241             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(return),
1242             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(save_mregister___rrR),
1243             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n0),
1244             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n1),
1245             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n2),
1246             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n3),
1247             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n4),
1248             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n5),
1249             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n6),
1250             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n7),
1251             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n8),
1252             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n9),
1253             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n10),
1254             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__nR),
1255             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n0),
1256             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n1),
1257             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n2),
1258             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n3),
1259             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n4),
1260             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n5),
1261             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n6),
1262             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n7),
1263             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n8),
1264             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n9),
1265             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n10),
1266             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__nR),
1267             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(unreachable),
1268             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch__fR_A_mno_mfast_mbranches),
1269             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches),
1270             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches),
1271             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches),
1272             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches),
1273             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches),
1274             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches),
1275             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches),
1276             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches),
1277             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches),
1278             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches),
1279             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches),
1280             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches),
1281             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches),
1282             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches),
1283             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches),
1284             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches),
1285             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches),
1286             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches),
1287             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches),
1288             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches),
1289             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches),
1290             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches),
1291             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches),
1292             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches),
1293             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches),
1294             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches),
1295             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches),
1296             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches),
1297             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches),
1298             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches),
1299             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches),
1300             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches),
1301             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches),
1302             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches),
1303             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches),
1304             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches),
1305             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches),
1306             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches),
1307             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches),
1308             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches),
1309             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches),
1310             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches),
1311             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches),
1312             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches),
1313             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches),
1314             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches),
1315             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches),
1316             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches),
1317             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches),
1318             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches),
1319             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches),
1320             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches),
1321             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches),
1322             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches),
1323             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches),
1324             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches),
1325             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches),
1326             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches),
1327             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches),
1328             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches),
1329             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches),
1330             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches),
1331             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches),
1332             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches),
1333             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches),
1334             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches),
1335             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches),
1336             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches),
1337             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches),
1338             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches),
1339             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches),
1340             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches),
1341             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches),
1342             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches),
1343             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches),
1344             && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches)
1345           };
1346       static const long
1347       jitterlispvm_the_thread_sizes [JITTERLISPVM_SPECIALIZED_INSTRUCTION_NO]
1348         = {
1349             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eINVALID))
1350                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID))),
1351             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eBEGINBASICBLOCK))
1352                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eBEGINBASICBLOCK))),
1353             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eEXITVM))
1354                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eEXITVM))),
1355             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eDATALOCATIONS))
1356                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eDATALOCATIONS))),
1357             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eNOP))
1358                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eNOP))),
1359             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE0))
1360                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE0))),
1361             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE1))
1362                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE1))),
1363             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_eUNREACHABLE2))
1364                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE2))),
1365             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n1___rrR))
1366                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n1___rrR))),
1367             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n2___rrR))
1368                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n2___rrR))),
1369             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n3___rrR))
1370                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n3___rrR))),
1371             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n4___rrR))
1372                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n4___rrR))),
1373             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n5___rrR))
1374                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n5___rrR))),
1375             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n6___rrR))
1376                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n6___rrR))),
1377             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n7___rrR))
1378                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n7___rrR))),
1379             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n8___rrR))
1380                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n8___rrR))),
1381             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n9___rrR))
1382                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n9___rrR))),
1383             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__n10___rrR))
1384                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n10___rrR))),
1385             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(at_mdepth_mto_mregister__nR___rrR))
1386                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__nR___rrR))),
1387             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch__fR))
1388                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch__fR))),
1389             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mfalse__fR))
1390                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mfalse__fR))),
1391             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnot_mless__fR__fR))
1392                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mless__fR__fR))),
1393             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnot_mnull__fR))
1394                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mnull__fR))),
1395             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mnull__fR))
1396                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnull__fR))),
1397             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mregister_mnon_mzero___rrR__fR__fR))
1398                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mnon_mzero___rrR__fR__fR))),
1399             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(branch_mif_mtrue__fR))
1400                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mtrue__fR))),
1401             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n0__retR))
1402                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n0__retR))),
1403             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n1__retR))
1404                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n1__retR))),
1405             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n2__retR))
1406                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n2__retR))),
1407             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n3__retR))
1408                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n3__retR))),
1409             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n4__retR))
1410                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n4__retR))),
1411             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n5__retR))
1412                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n5__retR))),
1413             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n6__retR))
1414                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n6__retR))),
1415             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n7__retR))
1416                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n7__retR))),
1417             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n8__retR))
1418                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n8__retR))),
1419             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n9__retR))
1420                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n9__retR))),
1421             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__n10__retR))
1422                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n10__retR))),
1423             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call__nR__retR))
1424                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__nR__retR))),
1425             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n0__retR))
1426                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n0__retR))),
1427             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n1__retR))
1428                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n1__retR))),
1429             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n2__retR))
1430                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n2__retR))),
1431             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n3__retR))
1432                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n3__retR))),
1433             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n4__retR))
1434                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n4__retR))),
1435             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n5__retR))
1436                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n5__retR))),
1437             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n6__retR))
1438                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n6__retR))),
1439             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n7__retR))
1440                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n7__retR))),
1441             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n8__retR))
1442                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n8__retR))),
1443             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n9__retR))
1444                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n9__retR))),
1445             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__n10__retR))
1446                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n10__retR))),
1447             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mcompiled__nR__retR))
1448                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__nR__retR))),
1449             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(call_mfrom_mc__retR))
1450                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mfrom_mc__retR))),
1451             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(canonicalize_mboolean))
1452                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(canonicalize_mboolean))),
1453             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_mclosure__fR))
1454                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mclosure__fR))),
1455             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_mglobal_mdefined__nR__fR))
1456                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mglobal_mdefined__nR__fR))),
1457             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n0__fR))
1458                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n0__fR))),
1459             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n1__fR))
1460                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n1__fR))),
1461             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n2__fR))
1462                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n2__fR))),
1463             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n3__fR))
1464                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n3__fR))),
1465             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n4__fR))
1466                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n4__fR))),
1467             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n5__fR))
1468                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n5__fR))),
1469             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n6__fR))
1470                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n6__fR))),
1471             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n7__fR))
1472                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n7__fR))),
1473             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n8__fR))
1474                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n8__fR))),
1475             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n9__fR))
1476                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n9__fR))),
1477             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__n10__fR))
1478                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n10__fR))),
1479             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity__nR__fR))
1480                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__nR__fR))),
1481             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n0__fR))
1482                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n0__fR))),
1483             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n1__fR))
1484                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n1__fR))),
1485             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n2__fR))
1486                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n2__fR))),
1487             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n3__fR))
1488                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n3__fR))),
1489             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n4__fR))
1490                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n4__fR))),
1491             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n5__fR))
1492                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n5__fR))),
1493             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n6__fR))
1494                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n6__fR))),
1495             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n7__fR))
1496                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n7__fR))),
1497             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n8__fR))
1498                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n8__fR))),
1499             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n9__fR))
1500                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n9__fR))),
1501             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__n10__fR))
1502                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n10__fR))),
1503             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(check_min_marity_m_malt__nR__fR))
1504                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__nR__fR))),
1505             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mfrom_mliteral__nR))
1506                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mliteral__nR))),
1507             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mfrom_mregister___rrR))
1508                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mregister___rrR))),
1509             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(copy_mto_mregister___rrR))
1510                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mto_mregister___rrR))),
1511             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop))
1512                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop))),
1513             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(drop_mnip))
1514                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop_mnip))),
1515             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(dup))
1516                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(dup))),
1517             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(exitvm))
1518                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exitvm))),
1519             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(fail__retR))
1520                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(fail__retR))),
1521             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(gc_mif_mneeded__fR))
1522                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gc_mif_mneeded__fR))),
1523             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n4))
1524                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n4))),
1525             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n8))
1526                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n8))),
1527             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n12))
1528                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n12))),
1529             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n16))
1530                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n16))),
1531             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n24))
1532                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n24))),
1533             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n32))
1534                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n32))),
1535             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n36))
1536                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n36))),
1537             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n48))
1538                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n48))),
1539             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n52))
1540                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n52))),
1541             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__n64))
1542                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n64))),
1543             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(heap_mallocate__nR))
1544                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__nR))),
1545             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(literal_mto_mregister__nR___rrR))
1546                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(literal_mto_mregister__nR___rrR))),
1547             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip))
1548                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip))),
1549             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mdrop))
1550                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mdrop))),
1551             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfive))
1552                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive))),
1553             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfive_mdrop))
1554                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive_mdrop))),
1555             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfour))
1556                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour))),
1557             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mfour_mdrop))
1558                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour_mdrop))),
1559             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mpush_mliteral__nR))
1560                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mliteral__nR))),
1561             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mpush_mregister___rrR))
1562                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mregister___rrR))),
1563             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_msix))
1564                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix))),
1565             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_msix_mdrop))
1566                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix_mdrop))),
1567             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mthree))
1568                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree))),
1569             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mthree_mdrop))
1570                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree_mdrop))),
1571             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mtwo))
1572                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo))),
1573             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nip_mtwo_mdrop))
1574                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo_mdrop))),
1575             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(nop))
1576                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nop))),
1577             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mglobal__nR__fR))
1578                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal__nR__fR))),
1579             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mglobal_mdefined__nR__fR))
1580                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal_mdefined__nR__fR))),
1581             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(pop_mto_mregister___rrR))
1582                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mregister___rrR))),
1583             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n0__fR))
1584                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n0__fR))),
1585             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n1__fR))
1586                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n1__fR))),
1587             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n2__fR))
1588                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n2__fR))),
1589             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n3__fR))
1590                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n3__fR))),
1591             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__n4__fR))
1592                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n4__fR))),
1593             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive__nR__nR__fR))
1594                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__nR__fR))),
1595             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mboolean_mcanonicalize))
1596                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mboolean_mcanonicalize))),
1597             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox))
1598                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox))),
1599             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox_mget__fR))
1600                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_mget__fR))),
1601             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mbox_msetb_mspecial__fR))
1602                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_msetb_mspecial__fR))),
1603             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcar__fR))
1604                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcar__fR))),
1605             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcdr__fR))
1606                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcdr__fR))),
1607             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcharacterp))
1608                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcharacterp))),
1609             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mcons_mspecial))
1610                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcons_mspecial))),
1611             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mconsp))
1612                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mconsp))),
1613             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_meqp))
1614                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_meqp))),
1615             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnum_meqp__fR))
1616                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_meqp__fR))),
1617             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnum_mnot_meqp__fR))
1618                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_mnot_meqp__fR))),
1619             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mfixnump))
1620                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnump))),
1621             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mgreaterp__fR))
1622                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mgreaterp__fR))),
1623             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mlessp__fR))
1624                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mlessp__fR))),
1625             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnegate__fR))
1626                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegate__fR))),
1627             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnegativep__fR))
1628                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegativep__fR))),
1629             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mconsp))
1630                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mconsp))),
1631             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mnegativep__fR))
1632                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnegativep__fR))),
1633             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mnullp))
1634                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnullp))),
1635             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mpositivep__fR))
1636                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mpositivep__fR))),
1637             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_msymbolp))
1638                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_msymbolp))),
1639             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnon_mzerop__fR))
1640                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mzerop__fR))),
1641             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot))
1642                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot))),
1643             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_meqp))
1644                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_meqp))),
1645             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_mgreaterp__fR))
1646                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mgreaterp__fR))),
1647             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnot_mlessp__fR))
1648                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mlessp__fR))),
1649             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnothingp))
1650                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnothingp))),
1651             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mnullp))
1652                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnullp))),
1653             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mone_mminus__fR))
1654                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mminus__fR))),
1655             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mone_mplus__fR))
1656                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mplus__fR))),
1657             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mpositivep__fR))
1658                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mpositivep__fR))),
1659             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mdivided__fR))
1660                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided__fR))),
1661             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mdivided_munsafe__fR))
1662                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided_munsafe__fR))),
1663             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mminus__fR))
1664                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mminus__fR))),
1665             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mplus__fR))
1666                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mplus__fR))),
1667             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mprimordial_mtimes__fR))
1668                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mtimes__fR))),
1669             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mquotient__fR))
1670                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient__fR))),
1671             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mquotient_munsafe__fR))
1672                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient_munsafe__fR))),
1673             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mremainder__fR))
1674                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder__fR))),
1675             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mremainder_munsafe__fR))
1676                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder_munsafe__fR))),
1677             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mset_mcarb_mspecial__fR))
1678                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcarb_mspecial__fR))),
1679             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mset_mcdrb_mspecial__fR))
1680                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcdrb_mspecial__fR))),
1681             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_msymbolp))
1682                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_msymbolp))),
1683             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mdivided__fR))
1684                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mdivided__fR))),
1685             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mquotient__fR))
1686                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mquotient__fR))),
1687             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mremainder__fR))
1688                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mremainder__fR))),
1689             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mtwo_mtimes__fR))
1690                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mtimes__fR))),
1691             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_muniquep))
1692                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_muniquep))),
1693             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(primitive_mzerop__fR))
1694                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mzerop__fR))),
1695             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(procedure_mprolog))
1696                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(procedure_mprolog))),
1697             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mfalse))
1698                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mfalse))),
1699             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mglobal__nR__fR))
1700                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mglobal__nR__fR))),
1701             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mliteral__nR))
1702                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mliteral__nR))),
1703             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mnil))
1704                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnil))),
1705             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mnothing))
1706                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnothing))),
1707             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mone))
1708                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mone))),
1709             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mregister___rrR))
1710                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mregister___rrR))),
1711             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_munspecified))
1712                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_munspecified))),
1713             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(push_mzero))
1714                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mzero))),
1715             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(register_mto_mregister___rrR___rrR))
1716                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(register_mto_mregister___rrR___rrR))),
1717             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(restore_mregister___rrR))
1718                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(restore_mregister___rrR))),
1719             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(return))
1720                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(return))),
1721             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(save_mregister___rrR))
1722                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(save_mregister___rrR))),
1723             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n0))
1724                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n0))),
1725             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n1))
1726                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n1))),
1727             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n2))
1728                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n2))),
1729             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n3))
1730                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n3))),
1731             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n4))
1732                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n4))),
1733             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n5))
1734                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n5))),
1735             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n6))
1736                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n6))),
1737             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n7))
1738                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n7))),
1739             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n8))
1740                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n8))),
1741             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n9))
1742                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n9))),
1743             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__n10))
1744                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n10))),
1745             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall__nR))
1746                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__nR))),
1747             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n0))
1748                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n0))),
1749             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n1))
1750                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n1))),
1751             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n2))
1752                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n2))),
1753             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n3))
1754                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n3))),
1755             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n4))
1756                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n4))),
1757             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n5))
1758                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n5))),
1759             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n6))
1760                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n6))),
1761             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n7))
1762                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n7))),
1763             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n8))
1764                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n8))),
1765             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n9))
1766                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n9))),
1767             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__n10))
1768                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n10))),
1769             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(tail_mcall_mcompiled__nR))
1770                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__nR))),
1771             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(unreachable))
1772                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unreachable))),
1773             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch__fR_A_mno_mfast_mbranches))
1774                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch__fR_A_mno_mfast_mbranches))),
1775             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches))
1776                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches))),
1777             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches))
1778                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches))),
1779             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches))
1780                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches))),
1781             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches))
1782                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches))),
1783             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches))
1784                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches))),
1785             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches))
1786                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches))),
1787             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches))
1788                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches))),
1789             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches))
1790                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches))),
1791             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches))
1792                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches))),
1793             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches))
1794                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches))),
1795             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches))
1796                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches))),
1797             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches))
1798                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches))),
1799             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches))
1800                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches))),
1801             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches))
1802                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches))),
1803             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches))
1804                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches))),
1805             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches))
1806                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches))),
1807             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches))
1808                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches))),
1809             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches))
1810                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches))),
1811             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches))
1812                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches))),
1813             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches))
1814                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches))),
1815             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches))
1816                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches))),
1817             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches))
1818                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches))),
1819             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches))
1820                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches))),
1821             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches))
1822                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches))),
1823             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches))
1824                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches))),
1825             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches))
1826                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches))),
1827             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches))
1828                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches))),
1829             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches))
1830                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches))),
1831             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches))
1832                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches))),
1833             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches))
1834                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches))),
1835             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches))
1836                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches))),
1837             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches))
1838                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches))),
1839             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches))
1840                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches))),
1841             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches))
1842                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches))),
1843             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches))
1844                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches))),
1845             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches))
1846                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches))),
1847             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches))
1848                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches))),
1849             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches))
1850                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches))),
1851             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches))
1852                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches))),
1853             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches))
1854                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches))),
1855             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches))
1856                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches))),
1857             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches))
1858                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches))),
1859             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches))
1860                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches))),
1861             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches))
1862                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches))),
1863             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches))
1864                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches))),
1865             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches))
1866                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches))),
1867             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches))
1868                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches))),
1869             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches))
1870                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches))),
1871             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches))
1872                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches))),
1873             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches))
1874                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches))),
1875             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches))
1876                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches))),
1877             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches))
1878                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches))),
1879             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches))
1880                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches))),
1881             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches))
1882                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches))),
1883             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches))
1884                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches))),
1885             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches))
1886                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches))),
1887             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches))
1888                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches))),
1889             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches))
1890                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches))),
1891             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches))
1892                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches))),
1893             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches))
1894                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches))),
1895             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches))
1896                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches))),
1897             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches))
1898                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches))),
1899             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches))
1900                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches))),
1901             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches))
1902                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches))),
1903             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches))
1904                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches))),
1905             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches))
1906                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches))),
1907             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches))
1908                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches))),
1909             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches))
1910                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches))),
1911             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches))
1912                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches))),
1913             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches))
1914                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches))),
1915             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches))
1916                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches))),
1917             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches))
1918                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches))),
1919             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches))
1920                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches))),
1921             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches))
1922                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches))),
1923             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches))
1924                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches))),
1925             (long) ((jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches))
1926                     - (jitter_int) (&& JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches)))
1927           };
1928       jitterlispvm_thread_sizes = jitterlispvm_the_thread_sizes;
1929       jitterlispvm_threads = jitterlispvm_the_threads;
1930       jitterlispvm_thread_ends = jitterlispvm_the_thread_ends;
1931 #ifdef JITTER_PROFILE
1932       fprintf (stderr, "VM instruction range: ");
1933       fprintf (stderr, "[%p, ", && JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID));
1934       fprintf (stderr, "%p)", && JITTER_SPECIALIZED_INSTRUCTION_END_LABEL_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches));
1935       fprintf (stderr, "\n");
1936 #endif // #ifdef JITTER_PROFILE
1937 #endif // #ifndef JITTER_DISPATCH_SWITCH
1938 
1939       /* Back to regular C, without our reserved registers if any; I can share
1940          the end code with the non-initialization case. */
1941 #ifdef JITTER_HAVE_PATCH_IN
1942       //JITTER_DUMP_PATCH_IN_DESCRIPTORS(jitterlispvm);
1943 #endif // #ifdef JITTER_HAVE_PATCH_IN
1944       goto jitter_possibly_restore_registers_and_return_label;
1945     }
1946 
1947 
1948   /* Here is the actual *executor* initialization, to be run before
1949      actually running the code. */
1950 
1951 /* Selectively suppress suprious -Wmaybe-uninitialized .
1952    The indirect jump hack I use in profiling mode in order to
1953    have a large gap inside a function introduced by assembler without
1954    being restricted by jump offset limits (intentionally) tricks GCC
1955    into believing that the indirect jump may reach any instruction label;
1956    GCC would then warn that some locals might be used uninitialized,
1957    by skipping over their initialization.  This however is not possible,
1958    and I want to selectively silence the warning for the variables in
1959    question. */
1960 #pragma GCC diagnostic push
1961 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
1962 
1963   /* Wrap functions and globals used within VM instructions, if needed.
1964      This is a trick to keep instructions readable while avoiding PC-relative
1965      addressing, which would mess up replicated code. */
1966 #ifdef JITTER_REPLICATE
1967 
1968   /* Protect the C globals used in VM instructions so that they are always
1969      referred thru a pointer (from a register or the stack) set in the
1970      non-replicated part.  This is necessary on architectures where I can't
1971      force global references to pass thru a GOT.
1972      [FIXME: possibly don't do this on architectures that don't need it.] */
1973 
1974   typeof (jitterlispvm_states) * volatile _my_volatile_pointer_to_jitterlispvm_states = & jitterlispvm_states;
1975   typeof (jitterlispvm_states) * const restrict _my_pointer_to_jitterlispvm_states __attribute__ ((unused))
1976      = _my_volatile_pointer_to_jitterlispvm_states;
1977 # undef jitterlispvm_states
1978 # define jitterlispvm_states (* _my_pointer_to_jitterlispvm_states)
1979 
1980   typeof (stack_printf_format_string) * volatile _my_volatile_pointer_to_stack_printf_format_string = & stack_printf_format_string;
1981   typeof (stack_printf_format_string) * const restrict _my_pointer_to_stack_printf_format_string __attribute__ ((unused))
1982      = _my_volatile_pointer_to_stack_printf_format_string;
1983 # undef stack_printf_format_string
1984 # define stack_printf_format_string (* _my_pointer_to_stack_printf_format_string)
1985 
1986   /* Similarly, wrap the C functions used in VM instructions, so that they are
1987      always called thru a function pointer.  This is necessary on architectures
1988      where call instructions represent the callee as a PC-relative address.
1989      Unfortunately C has a special quirky syntax for function pointers, so I
1990      can't just use the code above.  [FIXME: don't do this on architectures
1991      that don't need it.] */
1992   typeof (jitterlispvm_error_invalid_primitive_argument_type_friendly) * volatile _my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_friendly = & jitterlispvm_error_invalid_primitive_argument_type_friendly;
1993   typeof (jitterlispvm_error_invalid_primitive_argument_type_friendly) * const _my_jitterlispvm_error_invalid_primitive_argument_type_friendly __attribute__ ((unused))
1994      = * _my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_friendly;
1995 # undef jitterlispvm_error_invalid_primitive_argument_type_friendly
1996 # define jitterlispvm_error_invalid_primitive_argument_type_friendly _my_jitterlispvm_error_invalid_primitive_argument_type_friendly
1997 
1998   typeof (jitterlispvm_error_invalid_primitive_argument_type_unfriendly) * volatile _my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_unfriendly = & jitterlispvm_error_invalid_primitive_argument_type_unfriendly;
1999   typeof (jitterlispvm_error_invalid_primitive_argument_type_unfriendly) * const _my_jitterlispvm_error_invalid_primitive_argument_type_unfriendly __attribute__ ((unused))
2000      = * _my_volatile_pointer_to_jitterlispvm_error_invalid_primitive_argument_type_unfriendly;
2001 # undef jitterlispvm_error_invalid_primitive_argument_type_unfriendly
2002 # define jitterlispvm_error_invalid_primitive_argument_type_unfriendly _my_jitterlispvm_error_invalid_primitive_argument_type_unfriendly
2003 
2004   typeof (jitterlisp_fail_from_vm) * volatile _my_volatile_pointer_to_jitterlisp_fail_from_vm = & jitterlisp_fail_from_vm;
2005   typeof (jitterlisp_fail_from_vm) * const _my_jitterlisp_fail_from_vm __attribute__ ((unused))
2006      = * _my_volatile_pointer_to_jitterlisp_fail_from_vm;
2007 # undef jitterlisp_fail_from_vm
2008 # define jitterlisp_fail_from_vm _my_jitterlisp_fail_from_vm
2009 
2010   typeof (jitterlisp_allocate) * volatile _my_volatile_pointer_to_jitterlisp_allocate = & jitterlisp_allocate;
2011   typeof (jitterlisp_allocate) * const _my_jitterlisp_allocate __attribute__ ((unused))
2012      = * _my_volatile_pointer_to_jitterlisp_allocate;
2013 # undef jitterlisp_allocate
2014 # define jitterlisp_allocate _my_jitterlisp_allocate
2015 
2016   typeof (jitterlisp_call_interpreted) * volatile _my_volatile_pointer_to_jitterlisp_call_interpreted = & jitterlisp_call_interpreted;
2017   typeof (jitterlisp_call_interpreted) * const _my_jitterlisp_call_interpreted __attribute__ ((unused))
2018      = * _my_volatile_pointer_to_jitterlisp_call_interpreted;
2019 # undef jitterlisp_call_interpreted
2020 # define jitterlisp_call_interpreted _my_jitterlisp_call_interpreted
2021 
2022   typeof (jitterlisp_print) * volatile _my_volatile_pointer_to_jitterlisp_print = & jitterlisp_print;
2023   typeof (jitterlisp_print) * const _my_jitterlisp_print __attribute__ ((unused))
2024      = * _my_volatile_pointer_to_jitterlisp_print;
2025 # undef jitterlisp_print
2026 # define jitterlisp_print _my_jitterlisp_print
2027 
2028   typeof (debug_pointer) * volatile _my_volatile_pointer_to_debug_pointer = & debug_pointer;
2029   typeof (debug_pointer) * const _my_debug_pointer __attribute__ ((unused))
2030      = * _my_volatile_pointer_to_debug_pointer;
2031 # undef debug_pointer
2032 # define debug_pointer _my_debug_pointer
2033 
2034 /* See the comment above about spurious -Wmaybe-uninitialized warnings. */
2035 #pragma GCC diagnostic pop
2036 #endif // #ifdef JITTER_REPLICATE
2037 
2038 
2039   /* Make an automatic struct holding a copy of the state whose pointer was given.
2040      The idea is that the copy should be in registers, as far as possible. */
2041   struct jitterlispvm_state_runtime jitter_state_runtime
2042     = jitter_original_state->jitterlispvm_state_runtime;
2043 
2044   /* Initialize a pointer to The Array base.  This pointer will be in a
2045      global register variable with no-threading dispatch, and with
2046      other dispatches in an automatic variable, still hopefully kept
2047      in a register. */
2048 /* 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. */
2049 #pragma GCC diagnostic push
2050 #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
2051 #ifdef JITTER_DISPATCH_NO_THREADING
2052 # define jitter_array_base jitterlispvm_array_base_register_variable
2053 #else
2054   char * restrict jitter_array_base __attribute__ ((unused));
2055 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
2056 #pragma GCC diagnostic pop
2057   jitter_array_base
2058     = (((char *) jitter_original_state->jitterlispvm_state_backing.jitter_array)
2059        + JITTER_ARRAY_BIAS);
2060 
2061   /* Declare the instruction pointer from the thread array, unless the dispatching
2062      model is no-threading, in which case no thread array even exists. */
2063   jitterlispvm_program_point jitter_ip = NULL; /* Invalidate to catch errors. */
2064   /* Save an instruction address within this function, to jump to at VM exit
2065      time; that way we can be sure that at exit time we are back to
2066      non-replicated code, and stuff like PC-relative addressing work again
2067      without special tricks.  This variable may safely (and actually should,
2068      for performance) be kept on the stack.  We need it to be volatile to
2069      prevent the compiler from being too clever and jump to it using a
2070      PC-relative displacement from replicated code.   It must not be static,
2071      since non-automatic variables are problematic to access from replicated
2072      code, which might use PC-relative addressing. */
2073   volatile typeof (&& jitter_exit_vm_label) restrict
2074   jitter_saved_exit_non_replicated_code_pointer = &&jitter_exit_vm_label;
2075   JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(jitter_saved_exit_non_replicated_code_pointer);
2076 
2077 
2078 #ifdef JITTER_REPLICATE
2079   /* FIXME: comment. */
2080   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(fail__retR)
2081     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(fail__retR);
2082   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(fail__retR)) "\n"
2083                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(fail__retR)));
2084   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch__fR_A_mno_mfast_mbranches)
2085     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abranch__fR_A_mno_mfast_mbranches);
2086   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch__fR_A_mno_mfast_mbranches)) "\n"
2087                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch__fR_A_mno_mfast_mbranches)));
2088   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches)
2089     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches);
2090   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches)) "\n"
2091                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches)));
2092   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches)
2093     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches);
2094   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches)) "\n"
2095                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches)));
2096   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches)
2097     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches);
2098   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches)) "\n"
2099                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches)));
2100   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches)
2101     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches);
2102   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches)) "\n"
2103                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches)));
2104   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches)
2105     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches);
2106   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches)) "\n"
2107                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches)));
2108   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches)
2109     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches);
2110   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches)) "\n"
2111                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches)));
2112   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches)
2113     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches);
2114   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches)) "\n"
2115                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches)));
2116   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches)
2117     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches);
2118   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches)) "\n"
2119                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches)));
2120   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches)
2121     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches);
2122   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches)) "\n"
2123                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches)));
2124   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches)
2125     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches);
2126   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches)) "\n"
2127                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches)));
2128   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches)
2129     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches);
2130   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches)) "\n"
2131                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches)));
2132   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches)
2133     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches);
2134   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches)) "\n"
2135                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches)));
2136   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches)
2137     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches);
2138   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches)) "\n"
2139                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches)));
2140   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches)
2141     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches);
2142   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches)) "\n"
2143                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches)));
2144   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches)
2145     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches);
2146   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches)) "\n"
2147                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches)));
2148   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches)
2149     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches);
2150   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches)) "\n"
2151                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches)));
2152   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches)
2153     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches);
2154   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches)) "\n"
2155                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches)));
2156   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches)
2157     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches);
2158   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches)) "\n"
2159                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches)));
2160   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches)
2161     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches);
2162   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches)) "\n"
2163                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches)));
2164   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches)
2165     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches);
2166   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches)) "\n"
2167                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches)));
2168   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches)
2169     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches);
2170   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches)) "\n"
2171                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches)));
2172   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches)
2173     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches);
2174   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches)) "\n"
2175                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches)));
2176   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches)
2177     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches);
2178   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches)) "\n"
2179                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches)));
2180   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches)
2181     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches);
2182   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches)) "\n"
2183                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches)));
2184   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches)
2185     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches);
2186   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches)) "\n"
2187                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches)));
2188   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches)
2189     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches);
2190   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches)) "\n"
2191                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches)));
2192   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches)
2193     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches);
2194   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches)) "\n"
2195                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches)));
2196   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches)
2197     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches);
2198   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches)) "\n"
2199                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches)));
2200   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches)
2201     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches);
2202   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches)) "\n"
2203                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches)));
2204   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches)
2205     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches);
2206   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches)) "\n"
2207                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches)));
2208   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches)
2209     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches);
2210   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches)) "\n"
2211                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches)));
2212   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches)
2213     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches);
2214   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches)) "\n"
2215                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches)));
2216   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches)
2217     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches);
2218   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches)) "\n"
2219                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches)));
2220   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches)
2221     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches);
2222   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches)) "\n"
2223                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches)));
2224   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches)
2225     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches);
2226   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches)) "\n"
2227                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches)));
2228   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches)
2229     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches);
2230   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches)) "\n"
2231                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches)));
2232   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches)
2233     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches);
2234   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches)) "\n"
2235                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches)));
2236   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches)
2237     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches);
2238   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches)) "\n"
2239                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches)));
2240   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches)
2241     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches);
2242   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches)) "\n"
2243                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches)));
2244   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches)
2245     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches);
2246   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches)) "\n"
2247                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches)));
2248   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches)
2249     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches);
2250   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches)) "\n"
2251                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches)));
2252   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches)
2253     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches);
2254   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches)) "\n"
2255                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches)));
2256   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches)
2257     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches);
2258   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches)) "\n"
2259                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches)));
2260   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches)
2261     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches);
2262   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches)) "\n"
2263                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches)));
2264   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches)
2265     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches);
2266   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches)) "\n"
2267                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches)));
2268   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches)
2269     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches);
2270   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches)) "\n"
2271                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches)));
2272   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches)
2273     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches);
2274   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches)) "\n"
2275                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches)));
2276   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches)
2277     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches);
2278   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches)) "\n"
2279                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches)));
2280   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches)
2281     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches);
2282   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches)) "\n"
2283                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches)));
2284   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches)
2285     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches);
2286   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches)) "\n"
2287                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches)));
2288   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches)
2289     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches);
2290   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches)) "\n"
2291                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches)));
2292   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches)
2293     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches);
2294   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches)) "\n"
2295                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches)));
2296   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches)
2297     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches);
2298   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches)) "\n"
2299                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches)));
2300   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches)
2301     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches);
2302   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches)) "\n"
2303                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches)));
2304   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches)
2305     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches);
2306   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches)) "\n"
2307                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches)));
2308   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches)
2309     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches);
2310   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches)) "\n"
2311                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches)));
2312   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches)
2313     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches);
2314   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches)) "\n"
2315                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches)));
2316   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches)
2317     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches);
2318   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches)) "\n"
2319                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches)));
2320   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches)
2321     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches);
2322   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches)) "\n"
2323                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches)));
2324   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches)
2325     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches);
2326   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches)) "\n"
2327                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches)));
2328   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches)
2329     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches);
2330   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches)) "\n"
2331                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches)));
2332   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches)
2333     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches);
2334   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches)) "\n"
2335                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches)));
2336   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches)
2337     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches);
2338   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches)) "\n"
2339                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches)));
2340   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches)
2341     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches);
2342   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches)) "\n"
2343                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches)));
2344   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches)
2345     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches);
2346   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches)) "\n"
2347                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches)));
2348   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches)
2349     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches);
2350   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches)) "\n"
2351                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches)));
2352   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches)
2353     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches);
2354   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches)) "\n"
2355                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches)));
2356   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches)
2357     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches);
2358   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches)) "\n"
2359                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches)));
2360   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches)
2361     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches);
2362   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches)) "\n"
2363                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches)));
2364   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches)
2365     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches);
2366   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches)) "\n"
2367                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches)));
2368   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches)
2369     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches);
2370   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches)) "\n"
2371                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches)));
2372   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches)
2373     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches);
2374   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches)) "\n"
2375                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches)));
2376   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches)
2377     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches);
2378   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches)) "\n"
2379                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches)));
2380   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches)
2381     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches);
2382   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches)) "\n"
2383                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches)));
2384   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches)
2385     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches);
2386   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches)) "\n"
2387                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches)));
2388   volatile void *JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches)
2389     = && JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches);
2390   asm volatile ("#pretend to affect " JITTER_STRINGIFY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches)) "\n"
2391                 : "+m" (JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches)));
2392 #endif // #ifdef JITTER_REPLICATE
2393   /* Initialization C code from the user */
2394 
2395     /* End of the initialization C code from the user */
2396 
2397 
2398   /* Execute architecture-specific execution-beginning code, if any.
2399      Make sure it is safe to expand the macro without do..while
2400      (false). */
2401   {}; JITTER_EXECUTION_BEGINNING_; {};
2402 
2403 #if defined (JITTER_PROFILE_SAMPLE)
2404     /* Start sample-profiling: this starts the periodic timer signal,
2405        whose handler will look at the current instruction field within
2406        the special-purpose struct in the Array. */
2407     jitterlispvm_profile_sample_start (JITTERLISPVM_OWN_STATE);
2408 #endif // #if defined (JITTER_PROFILE_SAMPLE)
2409 
2410   /* Jump to the first instruction.  If replication is enabled this point
2411      marks the boundary between the ordinary world of C compiled code and
2412      the more fragile replicated code, where PC-relative address does
2413      not work as intended (which prevents the use of global and static
2414      variables, string literals and possibly large literal constants), and
2415      GDB gets easily confused. */
2416   jitter_ip = jitter_initial_program_point;
2417 
2418   /* This is the actual jump to the first instruction: it's not an
2419      inline asm constraint lie like below. */
2420 
2421 # if   defined(JITTER_DISPATCH_SWITCH)
2422     goto jitter_dispatching_switch_label;
2423 # elif (defined(JITTER_DISPATCH_DIRECT_THREADING)  \
2424         || defined(JITTER_DISPATCH_MINIMAL_THREADING))
2425     goto * (jitter_ip->label);
2426 # elif defined(JITTER_DISPATCH_NO_THREADING)
2427     /* On no-threading we only use jitter_ip for the first instruction.
2428        Make it an alias for the base, which will be enough to satisfy
2429        inline assembly code which pretends to alter the instruction
2430        pointer in ways invisible to the compiler.
2431        At least in my tests this trick frees up one hardware register,
2432        which is not surprising. */
2433     goto * jitter_ip;
2434 #   define jitter_ip jitterlispvm_array_base_register_variable
2435 # else
2436 #   error "unknown dispatch"
2437 # endif // if ... dispatch
2438   /* FIXME: comment: this is the fake dispatch routine. */
2439  /* The label is unused (from the compiler's point of view) for simple
2440     dispatches when not profiling.  (In reality it is always unused.)
2441     FIXME: comment. */
2442  jitter_dispatch_label: __attribute__ ((hot, unused))
2443 #if   defined(JITTER_DISPATCH_SWITCH)
2444   /* This code is unreachable, but the compiler does not know it.  FIXME: comment. */
2445   goto jitter_dispatching_switch_label;
2446 #elif defined(JITTER_DISPATCH_DIRECT_THREADING)
2447   /* Again this code is unreachable, but the compiler does not know it.  FIXME: comment. */
2448   goto * jitter_ip;
2449 #endif
2450 #ifdef JITTER_REPLICATE
2451   asm volatile ("\njitter_dispatch_label_asm:\n" :);
2452   JITTER_PRETEND_TO_UPDATE_IP_;
2453   JITTER_PRETEND_TO_UPDATE_IP_;
2454   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eINVALID));
2455   JITTER_PRETEND_TO_UPDATE_IP_;
2456   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eBEGINBASICBLOCK));
2457   JITTER_PRETEND_TO_UPDATE_IP_;
2458   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eEXITVM));
2459   JITTER_PRETEND_TO_UPDATE_IP_;
2460   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eDATALOCATIONS));
2461   JITTER_PRETEND_TO_UPDATE_IP_;
2462   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eNOP));
2463   JITTER_PRETEND_TO_UPDATE_IP_;
2464   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE0));
2465   JITTER_PRETEND_TO_UPDATE_IP_;
2466   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE1));
2467   JITTER_PRETEND_TO_UPDATE_IP_;
2468   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_eUNREACHABLE2));
2469   JITTER_PRETEND_TO_UPDATE_IP_;
2470   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n1___rrR));
2471   JITTER_PRETEND_TO_UPDATE_IP_;
2472   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n2___rrR));
2473   JITTER_PRETEND_TO_UPDATE_IP_;
2474   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n3___rrR));
2475   JITTER_PRETEND_TO_UPDATE_IP_;
2476   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n4___rrR));
2477   JITTER_PRETEND_TO_UPDATE_IP_;
2478   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n5___rrR));
2479   JITTER_PRETEND_TO_UPDATE_IP_;
2480   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n6___rrR));
2481   JITTER_PRETEND_TO_UPDATE_IP_;
2482   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n7___rrR));
2483   JITTER_PRETEND_TO_UPDATE_IP_;
2484   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n8___rrR));
2485   JITTER_PRETEND_TO_UPDATE_IP_;
2486   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n9___rrR));
2487   JITTER_PRETEND_TO_UPDATE_IP_;
2488   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__n10___rrR));
2489   JITTER_PRETEND_TO_UPDATE_IP_;
2490   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(at_mdepth_mto_mregister__nR___rrR));
2491   JITTER_PRETEND_TO_UPDATE_IP_;
2492   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch__fR));
2493   JITTER_PRETEND_TO_UPDATE_IP_;
2494   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mfalse__fR));
2495   JITTER_PRETEND_TO_UPDATE_IP_;
2496   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mless__fR__fR));
2497   JITTER_PRETEND_TO_UPDATE_IP_;
2498   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnot_mnull__fR));
2499   JITTER_PRETEND_TO_UPDATE_IP_;
2500   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mnull__fR));
2501   JITTER_PRETEND_TO_UPDATE_IP_;
2502   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mregister_mnon_mzero___rrR__fR__fR));
2503   JITTER_PRETEND_TO_UPDATE_IP_;
2504   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(branch_mif_mtrue__fR));
2505   JITTER_PRETEND_TO_UPDATE_IP_;
2506   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n0__retR));
2507   JITTER_PRETEND_TO_UPDATE_IP_;
2508   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n1__retR));
2509   JITTER_PRETEND_TO_UPDATE_IP_;
2510   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n2__retR));
2511   JITTER_PRETEND_TO_UPDATE_IP_;
2512   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n3__retR));
2513   JITTER_PRETEND_TO_UPDATE_IP_;
2514   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n4__retR));
2515   JITTER_PRETEND_TO_UPDATE_IP_;
2516   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n5__retR));
2517   JITTER_PRETEND_TO_UPDATE_IP_;
2518   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n6__retR));
2519   JITTER_PRETEND_TO_UPDATE_IP_;
2520   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n7__retR));
2521   JITTER_PRETEND_TO_UPDATE_IP_;
2522   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n8__retR));
2523   JITTER_PRETEND_TO_UPDATE_IP_;
2524   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n9__retR));
2525   JITTER_PRETEND_TO_UPDATE_IP_;
2526   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__n10__retR));
2527   JITTER_PRETEND_TO_UPDATE_IP_;
2528   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call__nR__retR));
2529   JITTER_PRETEND_TO_UPDATE_IP_;
2530   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n0__retR));
2531   JITTER_PRETEND_TO_UPDATE_IP_;
2532   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n1__retR));
2533   JITTER_PRETEND_TO_UPDATE_IP_;
2534   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n2__retR));
2535   JITTER_PRETEND_TO_UPDATE_IP_;
2536   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n3__retR));
2537   JITTER_PRETEND_TO_UPDATE_IP_;
2538   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n4__retR));
2539   JITTER_PRETEND_TO_UPDATE_IP_;
2540   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n5__retR));
2541   JITTER_PRETEND_TO_UPDATE_IP_;
2542   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n6__retR));
2543   JITTER_PRETEND_TO_UPDATE_IP_;
2544   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n7__retR));
2545   JITTER_PRETEND_TO_UPDATE_IP_;
2546   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n8__retR));
2547   JITTER_PRETEND_TO_UPDATE_IP_;
2548   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n9__retR));
2549   JITTER_PRETEND_TO_UPDATE_IP_;
2550   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__n10__retR));
2551   JITTER_PRETEND_TO_UPDATE_IP_;
2552   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mcompiled__nR__retR));
2553   JITTER_PRETEND_TO_UPDATE_IP_;
2554   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(call_mfrom_mc__retR));
2555   JITTER_PRETEND_TO_UPDATE_IP_;
2556   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(canonicalize_mboolean));
2557   JITTER_PRETEND_TO_UPDATE_IP_;
2558   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mclosure__fR));
2559   JITTER_PRETEND_TO_UPDATE_IP_;
2560   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_mglobal_mdefined__nR__fR));
2561   JITTER_PRETEND_TO_UPDATE_IP_;
2562   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n0__fR));
2563   JITTER_PRETEND_TO_UPDATE_IP_;
2564   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n1__fR));
2565   JITTER_PRETEND_TO_UPDATE_IP_;
2566   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n2__fR));
2567   JITTER_PRETEND_TO_UPDATE_IP_;
2568   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n3__fR));
2569   JITTER_PRETEND_TO_UPDATE_IP_;
2570   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n4__fR));
2571   JITTER_PRETEND_TO_UPDATE_IP_;
2572   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n5__fR));
2573   JITTER_PRETEND_TO_UPDATE_IP_;
2574   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n6__fR));
2575   JITTER_PRETEND_TO_UPDATE_IP_;
2576   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n7__fR));
2577   JITTER_PRETEND_TO_UPDATE_IP_;
2578   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n8__fR));
2579   JITTER_PRETEND_TO_UPDATE_IP_;
2580   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n9__fR));
2581   JITTER_PRETEND_TO_UPDATE_IP_;
2582   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__n10__fR));
2583   JITTER_PRETEND_TO_UPDATE_IP_;
2584   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity__nR__fR));
2585   JITTER_PRETEND_TO_UPDATE_IP_;
2586   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n0__fR));
2587   JITTER_PRETEND_TO_UPDATE_IP_;
2588   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n1__fR));
2589   JITTER_PRETEND_TO_UPDATE_IP_;
2590   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n2__fR));
2591   JITTER_PRETEND_TO_UPDATE_IP_;
2592   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n3__fR));
2593   JITTER_PRETEND_TO_UPDATE_IP_;
2594   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n4__fR));
2595   JITTER_PRETEND_TO_UPDATE_IP_;
2596   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n5__fR));
2597   JITTER_PRETEND_TO_UPDATE_IP_;
2598   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n6__fR));
2599   JITTER_PRETEND_TO_UPDATE_IP_;
2600   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n7__fR));
2601   JITTER_PRETEND_TO_UPDATE_IP_;
2602   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n8__fR));
2603   JITTER_PRETEND_TO_UPDATE_IP_;
2604   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n9__fR));
2605   JITTER_PRETEND_TO_UPDATE_IP_;
2606   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__n10__fR));
2607   JITTER_PRETEND_TO_UPDATE_IP_;
2608   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(check_min_marity_m_malt__nR__fR));
2609   JITTER_PRETEND_TO_UPDATE_IP_;
2610   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mliteral__nR));
2611   JITTER_PRETEND_TO_UPDATE_IP_;
2612   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mfrom_mregister___rrR));
2613   JITTER_PRETEND_TO_UPDATE_IP_;
2614   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(copy_mto_mregister___rrR));
2615   JITTER_PRETEND_TO_UPDATE_IP_;
2616   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop));
2617   JITTER_PRETEND_TO_UPDATE_IP_;
2618   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(drop_mnip));
2619   JITTER_PRETEND_TO_UPDATE_IP_;
2620   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(dup));
2621   JITTER_PRETEND_TO_UPDATE_IP_;
2622   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(exitvm));
2623   JITTER_PRETEND_TO_UPDATE_IP_;
2624   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(fail__retR));
2625   JITTER_PRETEND_TO_UPDATE_IP_;
2626   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(gc_mif_mneeded__fR));
2627   JITTER_PRETEND_TO_UPDATE_IP_;
2628   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n4));
2629   JITTER_PRETEND_TO_UPDATE_IP_;
2630   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n8));
2631   JITTER_PRETEND_TO_UPDATE_IP_;
2632   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n12));
2633   JITTER_PRETEND_TO_UPDATE_IP_;
2634   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n16));
2635   JITTER_PRETEND_TO_UPDATE_IP_;
2636   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n24));
2637   JITTER_PRETEND_TO_UPDATE_IP_;
2638   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n32));
2639   JITTER_PRETEND_TO_UPDATE_IP_;
2640   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n36));
2641   JITTER_PRETEND_TO_UPDATE_IP_;
2642   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n48));
2643   JITTER_PRETEND_TO_UPDATE_IP_;
2644   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n52));
2645   JITTER_PRETEND_TO_UPDATE_IP_;
2646   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__n64));
2647   JITTER_PRETEND_TO_UPDATE_IP_;
2648   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(heap_mallocate__nR));
2649   JITTER_PRETEND_TO_UPDATE_IP_;
2650   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(literal_mto_mregister__nR___rrR));
2651   JITTER_PRETEND_TO_UPDATE_IP_;
2652   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip));
2653   JITTER_PRETEND_TO_UPDATE_IP_;
2654   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mdrop));
2655   JITTER_PRETEND_TO_UPDATE_IP_;
2656   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive));
2657   JITTER_PRETEND_TO_UPDATE_IP_;
2658   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfive_mdrop));
2659   JITTER_PRETEND_TO_UPDATE_IP_;
2660   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour));
2661   JITTER_PRETEND_TO_UPDATE_IP_;
2662   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mfour_mdrop));
2663   JITTER_PRETEND_TO_UPDATE_IP_;
2664   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mliteral__nR));
2665   JITTER_PRETEND_TO_UPDATE_IP_;
2666   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mpush_mregister___rrR));
2667   JITTER_PRETEND_TO_UPDATE_IP_;
2668   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix));
2669   JITTER_PRETEND_TO_UPDATE_IP_;
2670   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_msix_mdrop));
2671   JITTER_PRETEND_TO_UPDATE_IP_;
2672   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree));
2673   JITTER_PRETEND_TO_UPDATE_IP_;
2674   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mthree_mdrop));
2675   JITTER_PRETEND_TO_UPDATE_IP_;
2676   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo));
2677   JITTER_PRETEND_TO_UPDATE_IP_;
2678   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nip_mtwo_mdrop));
2679   JITTER_PRETEND_TO_UPDATE_IP_;
2680   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(nop));
2681   JITTER_PRETEND_TO_UPDATE_IP_;
2682   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal__nR__fR));
2683   JITTER_PRETEND_TO_UPDATE_IP_;
2684   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mglobal_mdefined__nR__fR));
2685   JITTER_PRETEND_TO_UPDATE_IP_;
2686   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(pop_mto_mregister___rrR));
2687   JITTER_PRETEND_TO_UPDATE_IP_;
2688   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n0__fR));
2689   JITTER_PRETEND_TO_UPDATE_IP_;
2690   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n1__fR));
2691   JITTER_PRETEND_TO_UPDATE_IP_;
2692   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n2__fR));
2693   JITTER_PRETEND_TO_UPDATE_IP_;
2694   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n3__fR));
2695   JITTER_PRETEND_TO_UPDATE_IP_;
2696   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__n4__fR));
2697   JITTER_PRETEND_TO_UPDATE_IP_;
2698   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive__nR__nR__fR));
2699   JITTER_PRETEND_TO_UPDATE_IP_;
2700   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mboolean_mcanonicalize));
2701   JITTER_PRETEND_TO_UPDATE_IP_;
2702   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox));
2703   JITTER_PRETEND_TO_UPDATE_IP_;
2704   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_mget__fR));
2705   JITTER_PRETEND_TO_UPDATE_IP_;
2706   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mbox_msetb_mspecial__fR));
2707   JITTER_PRETEND_TO_UPDATE_IP_;
2708   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcar__fR));
2709   JITTER_PRETEND_TO_UPDATE_IP_;
2710   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcdr__fR));
2711   JITTER_PRETEND_TO_UPDATE_IP_;
2712   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcharacterp));
2713   JITTER_PRETEND_TO_UPDATE_IP_;
2714   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mcons_mspecial));
2715   JITTER_PRETEND_TO_UPDATE_IP_;
2716   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mconsp));
2717   JITTER_PRETEND_TO_UPDATE_IP_;
2718   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_meqp));
2719   JITTER_PRETEND_TO_UPDATE_IP_;
2720   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_meqp__fR));
2721   JITTER_PRETEND_TO_UPDATE_IP_;
2722   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnum_mnot_meqp__fR));
2723   JITTER_PRETEND_TO_UPDATE_IP_;
2724   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mfixnump));
2725   JITTER_PRETEND_TO_UPDATE_IP_;
2726   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mgreaterp__fR));
2727   JITTER_PRETEND_TO_UPDATE_IP_;
2728   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mlessp__fR));
2729   JITTER_PRETEND_TO_UPDATE_IP_;
2730   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegate__fR));
2731   JITTER_PRETEND_TO_UPDATE_IP_;
2732   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnegativep__fR));
2733   JITTER_PRETEND_TO_UPDATE_IP_;
2734   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mconsp));
2735   JITTER_PRETEND_TO_UPDATE_IP_;
2736   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnegativep__fR));
2737   JITTER_PRETEND_TO_UPDATE_IP_;
2738   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mnullp));
2739   JITTER_PRETEND_TO_UPDATE_IP_;
2740   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mpositivep__fR));
2741   JITTER_PRETEND_TO_UPDATE_IP_;
2742   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_msymbolp));
2743   JITTER_PRETEND_TO_UPDATE_IP_;
2744   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnon_mzerop__fR));
2745   JITTER_PRETEND_TO_UPDATE_IP_;
2746   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot));
2747   JITTER_PRETEND_TO_UPDATE_IP_;
2748   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_meqp));
2749   JITTER_PRETEND_TO_UPDATE_IP_;
2750   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mgreaterp__fR));
2751   JITTER_PRETEND_TO_UPDATE_IP_;
2752   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnot_mlessp__fR));
2753   JITTER_PRETEND_TO_UPDATE_IP_;
2754   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnothingp));
2755   JITTER_PRETEND_TO_UPDATE_IP_;
2756   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mnullp));
2757   JITTER_PRETEND_TO_UPDATE_IP_;
2758   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mminus__fR));
2759   JITTER_PRETEND_TO_UPDATE_IP_;
2760   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mone_mplus__fR));
2761   JITTER_PRETEND_TO_UPDATE_IP_;
2762   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mpositivep__fR));
2763   JITTER_PRETEND_TO_UPDATE_IP_;
2764   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided__fR));
2765   JITTER_PRETEND_TO_UPDATE_IP_;
2766   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mdivided_munsafe__fR));
2767   JITTER_PRETEND_TO_UPDATE_IP_;
2768   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mminus__fR));
2769   JITTER_PRETEND_TO_UPDATE_IP_;
2770   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mplus__fR));
2771   JITTER_PRETEND_TO_UPDATE_IP_;
2772   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mprimordial_mtimes__fR));
2773   JITTER_PRETEND_TO_UPDATE_IP_;
2774   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient__fR));
2775   JITTER_PRETEND_TO_UPDATE_IP_;
2776   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mquotient_munsafe__fR));
2777   JITTER_PRETEND_TO_UPDATE_IP_;
2778   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder__fR));
2779   JITTER_PRETEND_TO_UPDATE_IP_;
2780   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mremainder_munsafe__fR));
2781   JITTER_PRETEND_TO_UPDATE_IP_;
2782   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcarb_mspecial__fR));
2783   JITTER_PRETEND_TO_UPDATE_IP_;
2784   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mset_mcdrb_mspecial__fR));
2785   JITTER_PRETEND_TO_UPDATE_IP_;
2786   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_msymbolp));
2787   JITTER_PRETEND_TO_UPDATE_IP_;
2788   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mdivided__fR));
2789   JITTER_PRETEND_TO_UPDATE_IP_;
2790   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mquotient__fR));
2791   JITTER_PRETEND_TO_UPDATE_IP_;
2792   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mremainder__fR));
2793   JITTER_PRETEND_TO_UPDATE_IP_;
2794   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mtwo_mtimes__fR));
2795   JITTER_PRETEND_TO_UPDATE_IP_;
2796   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_muniquep));
2797   JITTER_PRETEND_TO_UPDATE_IP_;
2798   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(primitive_mzerop__fR));
2799   JITTER_PRETEND_TO_UPDATE_IP_;
2800   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(procedure_mprolog));
2801   JITTER_PRETEND_TO_UPDATE_IP_;
2802   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mfalse));
2803   JITTER_PRETEND_TO_UPDATE_IP_;
2804   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mglobal__nR__fR));
2805   JITTER_PRETEND_TO_UPDATE_IP_;
2806   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mliteral__nR));
2807   JITTER_PRETEND_TO_UPDATE_IP_;
2808   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnil));
2809   JITTER_PRETEND_TO_UPDATE_IP_;
2810   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mnothing));
2811   JITTER_PRETEND_TO_UPDATE_IP_;
2812   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mone));
2813   JITTER_PRETEND_TO_UPDATE_IP_;
2814   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mregister___rrR));
2815   JITTER_PRETEND_TO_UPDATE_IP_;
2816   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_munspecified));
2817   JITTER_PRETEND_TO_UPDATE_IP_;
2818   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(push_mzero));
2819   JITTER_PRETEND_TO_UPDATE_IP_;
2820   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(register_mto_mregister___rrR___rrR));
2821   JITTER_PRETEND_TO_UPDATE_IP_;
2822   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(restore_mregister___rrR));
2823   JITTER_PRETEND_TO_UPDATE_IP_;
2824   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(return));
2825   JITTER_PRETEND_TO_UPDATE_IP_;
2826   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(save_mregister___rrR));
2827   JITTER_PRETEND_TO_UPDATE_IP_;
2828   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n0));
2829   JITTER_PRETEND_TO_UPDATE_IP_;
2830   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n1));
2831   JITTER_PRETEND_TO_UPDATE_IP_;
2832   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n2));
2833   JITTER_PRETEND_TO_UPDATE_IP_;
2834   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n3));
2835   JITTER_PRETEND_TO_UPDATE_IP_;
2836   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n4));
2837   JITTER_PRETEND_TO_UPDATE_IP_;
2838   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n5));
2839   JITTER_PRETEND_TO_UPDATE_IP_;
2840   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n6));
2841   JITTER_PRETEND_TO_UPDATE_IP_;
2842   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n7));
2843   JITTER_PRETEND_TO_UPDATE_IP_;
2844   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n8));
2845   JITTER_PRETEND_TO_UPDATE_IP_;
2846   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n9));
2847   JITTER_PRETEND_TO_UPDATE_IP_;
2848   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__n10));
2849   JITTER_PRETEND_TO_UPDATE_IP_;
2850   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall__nR));
2851   JITTER_PRETEND_TO_UPDATE_IP_;
2852   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n0));
2853   JITTER_PRETEND_TO_UPDATE_IP_;
2854   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n1));
2855   JITTER_PRETEND_TO_UPDATE_IP_;
2856   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n2));
2857   JITTER_PRETEND_TO_UPDATE_IP_;
2858   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n3));
2859   JITTER_PRETEND_TO_UPDATE_IP_;
2860   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n4));
2861   JITTER_PRETEND_TO_UPDATE_IP_;
2862   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n5));
2863   JITTER_PRETEND_TO_UPDATE_IP_;
2864   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n6));
2865   JITTER_PRETEND_TO_UPDATE_IP_;
2866   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n7));
2867   JITTER_PRETEND_TO_UPDATE_IP_;
2868   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n8));
2869   JITTER_PRETEND_TO_UPDATE_IP_;
2870   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n9));
2871   JITTER_PRETEND_TO_UPDATE_IP_;
2872   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__n10));
2873   JITTER_PRETEND_TO_UPDATE_IP_;
2874   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(tail_mcall_mcompiled__nR));
2875   JITTER_PRETEND_TO_UPDATE_IP_;
2876   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(unreachable));
2877   JITTER_PRETEND_TO_UPDATE_IP_;
2878   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch__fR_A_mno_mfast_mbranches));
2879   JITTER_PRETEND_TO_UPDATE_IP_;
2880   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mfalse__fR_A_mno_mfast_mbranches));
2881   JITTER_PRETEND_TO_UPDATE_IP_;
2882   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches));
2883   JITTER_PRETEND_TO_UPDATE_IP_;
2884   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches));
2885   JITTER_PRETEND_TO_UPDATE_IP_;
2886   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mnull__fR_A_mno_mfast_mbranches));
2887   JITTER_PRETEND_TO_UPDATE_IP_;
2888   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches));
2889   JITTER_PRETEND_TO_UPDATE_IP_;
2890   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Abranch_mif_mtrue__fR_A_mno_mfast_mbranches));
2891   JITTER_PRETEND_TO_UPDATE_IP_;
2892   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_mclosure__fR_A_mno_mfast_mbranches));
2893   JITTER_PRETEND_TO_UPDATE_IP_;
2894   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches));
2895   JITTER_PRETEND_TO_UPDATE_IP_;
2896   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n0__fR_A_mno_mfast_mbranches));
2897   JITTER_PRETEND_TO_UPDATE_IP_;
2898   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n1__fR_A_mno_mfast_mbranches));
2899   JITTER_PRETEND_TO_UPDATE_IP_;
2900   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n2__fR_A_mno_mfast_mbranches));
2901   JITTER_PRETEND_TO_UPDATE_IP_;
2902   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n3__fR_A_mno_mfast_mbranches));
2903   JITTER_PRETEND_TO_UPDATE_IP_;
2904   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n4__fR_A_mno_mfast_mbranches));
2905   JITTER_PRETEND_TO_UPDATE_IP_;
2906   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n5__fR_A_mno_mfast_mbranches));
2907   JITTER_PRETEND_TO_UPDATE_IP_;
2908   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n6__fR_A_mno_mfast_mbranches));
2909   JITTER_PRETEND_TO_UPDATE_IP_;
2910   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n7__fR_A_mno_mfast_mbranches));
2911   JITTER_PRETEND_TO_UPDATE_IP_;
2912   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n8__fR_A_mno_mfast_mbranches));
2913   JITTER_PRETEND_TO_UPDATE_IP_;
2914   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n9__fR_A_mno_mfast_mbranches));
2915   JITTER_PRETEND_TO_UPDATE_IP_;
2916   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__n10__fR_A_mno_mfast_mbranches));
2917   JITTER_PRETEND_TO_UPDATE_IP_;
2918   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity__nR__fR_A_mno_mfast_mbranches));
2919   JITTER_PRETEND_TO_UPDATE_IP_;
2920   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches));
2921   JITTER_PRETEND_TO_UPDATE_IP_;
2922   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches));
2923   JITTER_PRETEND_TO_UPDATE_IP_;
2924   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches));
2925   JITTER_PRETEND_TO_UPDATE_IP_;
2926   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches));
2927   JITTER_PRETEND_TO_UPDATE_IP_;
2928   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches));
2929   JITTER_PRETEND_TO_UPDATE_IP_;
2930   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches));
2931   JITTER_PRETEND_TO_UPDATE_IP_;
2932   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches));
2933   JITTER_PRETEND_TO_UPDATE_IP_;
2934   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches));
2935   JITTER_PRETEND_TO_UPDATE_IP_;
2936   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches));
2937   JITTER_PRETEND_TO_UPDATE_IP_;
2938   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches));
2939   JITTER_PRETEND_TO_UPDATE_IP_;
2940   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches));
2941   JITTER_PRETEND_TO_UPDATE_IP_;
2942   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches));
2943   JITTER_PRETEND_TO_UPDATE_IP_;
2944   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Agc_mif_mneeded__fR_A_mno_mfast_mbranches));
2945   JITTER_PRETEND_TO_UPDATE_IP_;
2946   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches));
2947   JITTER_PRETEND_TO_UPDATE_IP_;
2948   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches));
2949   JITTER_PRETEND_TO_UPDATE_IP_;
2950   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n0__fR_A_mno_mfast_mbranches));
2951   JITTER_PRETEND_TO_UPDATE_IP_;
2952   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n1__fR_A_mno_mfast_mbranches));
2953   JITTER_PRETEND_TO_UPDATE_IP_;
2954   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n2__fR_A_mno_mfast_mbranches));
2955   JITTER_PRETEND_TO_UPDATE_IP_;
2956   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n3__fR_A_mno_mfast_mbranches));
2957   JITTER_PRETEND_TO_UPDATE_IP_;
2958   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__n4__fR_A_mno_mfast_mbranches));
2959   JITTER_PRETEND_TO_UPDATE_IP_;
2960   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive__nR__nR__fR_A_mno_mfast_mbranches));
2961   JITTER_PRETEND_TO_UPDATE_IP_;
2962   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches));
2963   JITTER_PRETEND_TO_UPDATE_IP_;
2964   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches));
2965   JITTER_PRETEND_TO_UPDATE_IP_;
2966   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mcar__fR_A_mno_mfast_mbranches));
2967   JITTER_PRETEND_TO_UPDATE_IP_;
2968   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mcdr__fR_A_mno_mfast_mbranches));
2969   JITTER_PRETEND_TO_UPDATE_IP_;
2970   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches));
2971   JITTER_PRETEND_TO_UPDATE_IP_;
2972   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches));
2973   JITTER_PRETEND_TO_UPDATE_IP_;
2974   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches));
2975   JITTER_PRETEND_TO_UPDATE_IP_;
2976   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mlessp__fR_A_mno_mfast_mbranches));
2977   JITTER_PRETEND_TO_UPDATE_IP_;
2978   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnegate__fR_A_mno_mfast_mbranches));
2979   JITTER_PRETEND_TO_UPDATE_IP_;
2980   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnegativep__fR_A_mno_mfast_mbranches));
2981   JITTER_PRETEND_TO_UPDATE_IP_;
2982   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches));
2983   JITTER_PRETEND_TO_UPDATE_IP_;
2984   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches));
2985   JITTER_PRETEND_TO_UPDATE_IP_;
2986   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches));
2987   JITTER_PRETEND_TO_UPDATE_IP_;
2988   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches));
2989   JITTER_PRETEND_TO_UPDATE_IP_;
2990   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches));
2991   JITTER_PRETEND_TO_UPDATE_IP_;
2992   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches));
2993   JITTER_PRETEND_TO_UPDATE_IP_;
2994   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches));
2995   JITTER_PRETEND_TO_UPDATE_IP_;
2996   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mpositivep__fR_A_mno_mfast_mbranches));
2997   JITTER_PRETEND_TO_UPDATE_IP_;
2998   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches));
2999   JITTER_PRETEND_TO_UPDATE_IP_;
3000   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches));
3001   JITTER_PRETEND_TO_UPDATE_IP_;
3002   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches));
3003   JITTER_PRETEND_TO_UPDATE_IP_;
3004   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches));
3005   JITTER_PRETEND_TO_UPDATE_IP_;
3006   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches));
3007   JITTER_PRETEND_TO_UPDATE_IP_;
3008   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mquotient__fR_A_mno_mfast_mbranches));
3009   JITTER_PRETEND_TO_UPDATE_IP_;
3010   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches));
3011   JITTER_PRETEND_TO_UPDATE_IP_;
3012   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mremainder__fR_A_mno_mfast_mbranches));
3013   JITTER_PRETEND_TO_UPDATE_IP_;
3014   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches));
3015   JITTER_PRETEND_TO_UPDATE_IP_;
3016   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches));
3017   JITTER_PRETEND_TO_UPDATE_IP_;
3018   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches));
3019   JITTER_PRETEND_TO_UPDATE_IP_;
3020   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches));
3021   JITTER_PRETEND_TO_UPDATE_IP_;
3022   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches));
3023   JITTER_PRETEND_TO_UPDATE_IP_;
3024   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches));
3025   JITTER_PRETEND_TO_UPDATE_IP_;
3026   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches));
3027   JITTER_PRETEND_TO_UPDATE_IP_;
3028   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Aprimitive_mzerop__fR_A_mno_mfast_mbranches));
3029   JITTER_PRETEND_TO_UPDATE_IP_;
3030   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(JITTER_SPECIALIZED_INSTRUCTION_BEGIN_LABEL_OF(_Apush_mglobal__nR__fR_A_mno_mfast_mbranches));
3031   JITTER_PRETEND_TO_UPDATE_IP_;
3032   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(jitter_exit_vm_label);
3033   JITTER_PRETEND_TO_UPDATE_IP_;
3034   JITTER_PRETEND_TO_POSSIBLY_JUMP_TO_(jitter_possibly_restore_registers_and_return_label);
3035   goto jitter_dispatch_label;
3036 #endif // #ifdef JITTER_REPLICATE
3037 
3038 #ifdef JITTER_DISPATCH_SWITCH
3039   /* This is the dispatching switch.  At the beginning of the first VM
3040      VM instruction and at the end of each other, control jumps here. */
3041  jitter_dispatching_switch_label:
3042   switch (jitter_ip->fixnum)
3043     {
3044 #endif // #ifdef JITTER_DISPATCH_SWITCH
3045 
3046 JITTER_INSTRUCTION_PROLOG_(!INVALID, _eINVALID, cold)
3047 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3048 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  0
3049 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !INVALID
3050 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eINVALID
3051 {
3052 
3053 jitter_fatal ("reached the !INVALID instruction");
3054 }
3055 JITTER_INSTRUCTION_EPILOG_(!INVALID, _eINVALID, 0)
3056 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3057 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3058 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3059 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3060 
3061 JITTER_INSTRUCTION_PROLOG_(!BEGINBASICBLOCK, _eBEGINBASICBLOCK, hot)
3062 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3063 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  1
3064 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !BEGINBASICBLOCK
3065 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eBEGINBASICBLOCK
3066 {
3067 
3068 #ifdef JITTER_DISPATCH_MINIMAL_THREADING
3069   JITTER_SET_IP (jitter_ip + 1);
3070 #endif // #ifdef JITTER_DISPATCH_MINIMAL_THREADING
3071 
3072 }
3073 JITTER_INSTRUCTION_EPILOG_(!BEGINBASICBLOCK, _eBEGINBASICBLOCK, 0)
3074 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3075 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3076 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3077 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3078 
3079 JITTER_INSTRUCTION_PROLOG_(!EXITVM, _eEXITVM, cold)
3080 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3081 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  2
3082 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !EXITVM
3083 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eEXITVM
3084 {
3085 
3086 JITTER_EXIT();
3087 }
3088 JITTER_INSTRUCTION_EPILOG_(!EXITVM, _eEXITVM, 0)
3089 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3090 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3091 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3092 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3093 
3094 JITTER_INSTRUCTION_PROLOG_(!DATALOCATIONS, _eDATALOCATIONS, cold)
3095 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3096 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  3
3097 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !DATALOCATIONS
3098 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eDATALOCATIONS
3099 {
3100 #ifndef JITTER_DISPATCH_SWITCH
3101 #ifndef JITTER_DISPATCH_NO_THREADING
3102   JITTER_DATA_LOCATION_DATUM ("instruction pointer", jitter_ip);
3103 #endif // #ifndef JITTER_DISPATCH_NO_THREADING
3104   JITTER_DATA_LOCATION_DATUM ("base", jitter_array_base);
3105 #ifdef JITTER_DISPATCH_NO_THREADING
3106 #ifdef JITTER_SCRATCH_REGISTER
3107   JITTER_DATA_LOCATION_DATUM ("scratch", jitter_residual_argument_scratch_register_variable);
3108 #endif // #ifdef JITTER_SCRATCH_REGISTER
3109 
3110 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
3111 #ifdef JITTER_DISPATCH_NO_THREADING
3112 #if (0 < JITTER_RESIDUAL_REGISTER_NO)
3113   JITTER_DATA_LOCATION_DATUM ("residual 0", jitter_residual_argument_0_register_variable);
3114 #endif // #if (0 < JITTER_RESIDUAL_REGISTER_NO)
3115 #if (1 < JITTER_RESIDUAL_REGISTER_NO)
3116   JITTER_DATA_LOCATION_DATUM ("residual 1", jitter_residual_argument_1_register_variable);
3117 #endif // #if (1 < JITTER_RESIDUAL_REGISTER_NO)
3118 #if (2 < JITTER_RESIDUAL_REGISTER_NO)
3119   JITTER_DATA_LOCATION_DATUM ("residual 2", jitter_residual_argument_2_register_variable);
3120 #endif // #if (2 < JITTER_RESIDUAL_REGISTER_NO)
3121 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
3122 #if    defined(JITTER_DISPATCH_SWITCH)                    \
3123     || defined(JITTER_DISPATCH_DIRECT_THREADING)          \
3124     || defined(JITTER_DISPATCH_MINIMAL_THREADING)         \
3125     || (   defined(JITTER_DISPATCH_NO_THREADING)          \
3126         && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE))
3127 
3128   JITTER_DATA_LOCATION_DATUM ("link register", jitter_state_runtime._jitter_link);
3129 #endif // link register
3130   JITTER_DATA_LOCATION_DATUM ("mainstack top",
3131      JITTER_STACK_TOS_TOP_NAME (whatever, jitter_state_runtime., mainstack));
3132   JITTER_DATA_LOCATION_DATUM ("mainstack undertop ptr",
3133      JITTER_STACK_TOS_UNDER_TOP_POINTER_NAME (whatever, jitter_state_runtime., mainstack));
3134   JITTER_DATA_LOCATION_DATUM ("returnstack top ptr",
3135      JITTER_STACK_NTOS_TOP_POINTER_NAME (whatever, jitter_state_runtime., returnstack));
3136 #endif // #ifndef JITTER_DISPATCH_SWITCH
3137 }
3138 JITTER_INSTRUCTION_EPILOG_(!DATALOCATIONS, _eDATALOCATIONS, 0)
3139 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3140 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3141 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3142 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3143 
3144 JITTER_INSTRUCTION_PROLOG_(!NOP, _eNOP, cold)
3145 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3146 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  4
3147 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !NOP
3148 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eNOP
3149 {
3150 
3151   /* Do nothing. */;
3152 }
3153 JITTER_INSTRUCTION_EPILOG_(!NOP, _eNOP, 0)
3154 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3155 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3156 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3157 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3158 
3159 JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE0, _eUNREACHABLE0, cold)
3160 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3161 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  5
3162 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE0
3163 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE0
3164 {
3165 
3166 jitter_fatal ("reached the !UNREACHABLE0 instruction");
3167 }
3168 JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE0, _eUNREACHABLE0, 0)
3169 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3170 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3171 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3172 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3173 
3174 JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE1, _eUNREACHABLE1, cold)
3175 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3176 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  6
3177 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE1
3178 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE1
3179 {
3180 
3181 jitter_fatal ("reached the !UNREACHABLE1 instruction");
3182 }
3183 JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE1, _eUNREACHABLE1, 0)
3184 #undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3185 #undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3186 #undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3187 #undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3188 
3189 JITTER_INSTRUCTION_PROLOG_(!UNREACHABLE2, _eUNREACHABLE2, cold)
3190 #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
3191 #define JITTER_SPECIALIZED_INSTRUCTION_OPCODE  7
3192 #define JITTER_SPECIALIZED_INSTRUCTION_NAME  !UNREACHABLE2
3193 #define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME  _eUNREACHABLE2
3194 {
3195 
3196 jitter_fatal ("reached the !UNREACHABLE2 instruction");
3197 }
3198 JITTER_INSTRUCTION_EPILOG_(!UNREACHABLE2, _eUNREACHABLE2, 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   /* Ordinary specialized instructions. */
3205   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n1/%rR, at_mdepth_mto_mregister__n1___rrR, cold)
3206   {
3207     /* This specialized instruction is not a replacement. */
3208 #   undef JITTER_BRANCH_FAST
3209 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3210 #   undef JITTER_BRANCH_FAST_IF_ZERO
3211 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3212 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3213 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3214 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3215 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3216 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3217 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3218 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3219 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3220 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3221 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3222 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3223 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3224 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3225 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3226 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3227 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3228 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3229 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3230 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3231 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3232 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3233 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3234 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3235 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3236 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3237 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3238 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3239 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3240 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3241 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3242 #   undef JITTER_BRANCH_FAST_IF_AND
3243 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3244 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3245 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3246 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3247 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3248 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3249 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3250 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3251 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3252 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3253 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3254 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3255 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3256 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3257 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3258 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3259 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3260 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3261 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3262 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3263 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3264 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3265 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3266 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3267 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3268 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3269 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3270 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3271 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3272 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       8
3273 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n1/%rR
3274 
3275 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n1___rrR
3276 
3277   /* The residual arity for this instruction does not depend on fast labels. */
3278   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
3279 
3280     /* The 0th argument is a nonresidual literal. */
3281 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
3282 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
3283 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
3284 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
3285 #   define JITTER_ARGF0 JITTER_ARGP0
3286 
3287     /* The 1th argument is a slow (therefore residual, passed as an offset)
3288         register. */
3289   /* Define a macro expanding to the slow register offset. */
3290 #if defined(JITTER_DISPATCH_NO_THREADING)
3291 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
3292 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
3293 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
3294 #else
3295 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
3296 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
3297   /* Define a macro expanding to an l-value for the VM register content. */
3298 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
3299 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
3300 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
3301 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
3302 #   define JITTER_ARGF1 JITTER_ARGP1
3303 
3304 
3305 #if defined (JITTER_PROFILE_SAMPLE)
3306   JITTER_PROFILE_SAMPLE_UPDATE
3307      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3308       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3309   /* Force the compiler not move sample-profiling instrumentation
3310      beyond this point; this way the actual user code is timed.
3311      This is still not perfect, as residuals are materialised before
3312      we arrive here, but should be adequate at least for slow VM
3313      instructions. */
3314   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3315 #endif
3316 #if defined (JITTER_PROFILE_COUNT)
3317   /* Notice that, differently from the code above, this
3318      instrumentation code *can* be reordered freely: as long as a
3319      VM instruction is counted, the count increment can be placed
3320      anyehere.  Let GCC move this code and possibly achieve better
3321      throughput by exploiting instruction-level parallelism and
3322      therefore approximate more closely a non-profiled build. */
3323   JITTER_PROFILE_COUNT_UPDATE
3324      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3325       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3326 #endif
3327 
3328 /* User-specified code, instruction-beginning-c part: beginning. */
3329 
3330 
3331 /* User-specified code, instruction-beginning-c part: end */
3332 
3333 
3334     /* User code for at-depth-to-register/n1/%rR . */
3335 
3336     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
3337     // unsafe at-depth operations.
3338     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
3339 
3340     /* End of the user code for at-depth-to-register/n1/%rR . */
3341 
3342 /* User-specified code, instruction-end-c part: beginning. */
3343 
3344 
3345 /* User-specified code, instruction-end-c part: end */
3346 
3347     /* Undefine the at-depth-to-register/n1/%rR argument macros so they can't be used
3348        by mistake in the instruction body coming next. */
3349 #   undef JITTER_SLOW_REGISTER_OFFSET0
3350 #   undef JITTER_ARG0
3351 #   undef JITTER_ARGN0
3352 #   undef JITTER_ARGU0
3353 #   undef JITTER_ARGP0
3354 #   undef JITTER_ARGF0
3355 #   undef JITTER_SLOW_REGISTER_OFFSET1
3356 #   undef JITTER_ARG1
3357 #   undef JITTER_ARGN1
3358 #   undef JITTER_ARGU1
3359 #   undef JITTER_ARGP1
3360 #   undef JITTER_ARGF1
3361 
3362 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3363 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3364 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3365 
3366   }
3367  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n1/%rR, at_mdepth_mto_mregister__n1___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3368 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3369 
3370   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n2/%rR, at_mdepth_mto_mregister__n2___rrR, cold)
3371   {
3372     /* This specialized instruction is not a replacement. */
3373 #   undef JITTER_BRANCH_FAST
3374 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3375 #   undef JITTER_BRANCH_FAST_IF_ZERO
3376 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3377 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3378 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3379 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3380 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3381 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3382 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3383 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3384 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3385 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3386 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3387 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3388 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3389 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3390 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3391 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3392 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3393 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3394 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3395 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3396 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3397 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3398 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3399 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3400 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3401 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3402 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3403 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3404 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3405 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3406 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3407 #   undef JITTER_BRANCH_FAST_IF_AND
3408 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3409 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3410 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3411 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3412 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3413 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3414 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3415 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3416 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3417 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3418 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3419 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3420 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3421 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3422 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3423 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3424 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3425 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3426 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3427 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3428 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3429 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3430 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3431 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3432 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3433 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3434 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3435 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3436 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3437 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       9
3438 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n2/%rR
3439 
3440 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n2___rrR
3441 
3442   /* The residual arity for this instruction does not depend on fast labels. */
3443   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
3444 
3445     /* The 0th argument is a nonresidual literal. */
3446 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
3447 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
3448 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
3449 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
3450 #   define JITTER_ARGF0 JITTER_ARGP0
3451 
3452     /* The 1th argument is a slow (therefore residual, passed as an offset)
3453         register. */
3454   /* Define a macro expanding to the slow register offset. */
3455 #if defined(JITTER_DISPATCH_NO_THREADING)
3456 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
3457 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
3458 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
3459 #else
3460 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
3461 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
3462   /* Define a macro expanding to an l-value for the VM register content. */
3463 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
3464 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
3465 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
3466 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
3467 #   define JITTER_ARGF1 JITTER_ARGP1
3468 
3469 
3470 #if defined (JITTER_PROFILE_SAMPLE)
3471   JITTER_PROFILE_SAMPLE_UPDATE
3472      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3473       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3474   /* Force the compiler not move sample-profiling instrumentation
3475      beyond this point; this way the actual user code is timed.
3476      This is still not perfect, as residuals are materialised before
3477      we arrive here, but should be adequate at least for slow VM
3478      instructions. */
3479   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3480 #endif
3481 #if defined (JITTER_PROFILE_COUNT)
3482   /* Notice that, differently from the code above, this
3483      instrumentation code *can* be reordered freely: as long as a
3484      VM instruction is counted, the count increment can be placed
3485      anyehere.  Let GCC move this code and possibly achieve better
3486      throughput by exploiting instruction-level parallelism and
3487      therefore approximate more closely a non-profiled build. */
3488   JITTER_PROFILE_COUNT_UPDATE
3489      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3490       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3491 #endif
3492 
3493 /* User-specified code, instruction-beginning-c part: beginning. */
3494 
3495 
3496 /* User-specified code, instruction-beginning-c part: end */
3497 
3498 
3499     /* User code for at-depth-to-register/n2/%rR . */
3500 
3501     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
3502     // unsafe at-depth operations.
3503     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
3504 
3505     /* End of the user code for at-depth-to-register/n2/%rR . */
3506 
3507 /* User-specified code, instruction-end-c part: beginning. */
3508 
3509 
3510 /* User-specified code, instruction-end-c part: end */
3511 
3512     /* Undefine the at-depth-to-register/n2/%rR argument macros so they can't be used
3513        by mistake in the instruction body coming next. */
3514 #   undef JITTER_SLOW_REGISTER_OFFSET0
3515 #   undef JITTER_ARG0
3516 #   undef JITTER_ARGN0
3517 #   undef JITTER_ARGU0
3518 #   undef JITTER_ARGP0
3519 #   undef JITTER_ARGF0
3520 #   undef JITTER_SLOW_REGISTER_OFFSET1
3521 #   undef JITTER_ARG1
3522 #   undef JITTER_ARGN1
3523 #   undef JITTER_ARGU1
3524 #   undef JITTER_ARGP1
3525 #   undef JITTER_ARGF1
3526 
3527 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3528 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3529 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3530 
3531   }
3532  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n2/%rR, at_mdepth_mto_mregister__n2___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3533 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3534 
3535   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n3/%rR, at_mdepth_mto_mregister__n3___rrR, cold)
3536   {
3537     /* This specialized instruction is not a replacement. */
3538 #   undef JITTER_BRANCH_FAST
3539 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3540 #   undef JITTER_BRANCH_FAST_IF_ZERO
3541 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3542 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3543 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3544 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3545 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3546 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3547 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3548 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3549 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3550 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3551 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3552 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3553 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3554 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3555 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3556 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3557 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3558 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3559 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3560 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3561 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3562 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3563 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3564 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3565 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3566 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3567 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3568 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3569 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3570 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3571 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3572 #   undef JITTER_BRANCH_FAST_IF_AND
3573 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3574 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3575 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3576 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3577 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3578 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3579 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3580 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3581 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3582 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3583 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3584 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3585 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3586 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3587 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3588 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3589 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3590 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3591 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3592 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3593 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3594 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3595 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3596 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3597 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3598 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3599 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3600 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3601 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3602 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       10
3603 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n3/%rR
3604 
3605 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n3___rrR
3606 
3607   /* The residual arity for this instruction does not depend on fast labels. */
3608   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
3609 
3610     /* The 0th argument is a nonresidual literal. */
3611 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
3612 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
3613 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
3614 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
3615 #   define JITTER_ARGF0 JITTER_ARGP0
3616 
3617     /* The 1th argument is a slow (therefore residual, passed as an offset)
3618         register. */
3619   /* Define a macro expanding to the slow register offset. */
3620 #if defined(JITTER_DISPATCH_NO_THREADING)
3621 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
3622 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
3623 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
3624 #else
3625 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
3626 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
3627   /* Define a macro expanding to an l-value for the VM register content. */
3628 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
3629 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
3630 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
3631 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
3632 #   define JITTER_ARGF1 JITTER_ARGP1
3633 
3634 
3635 #if defined (JITTER_PROFILE_SAMPLE)
3636   JITTER_PROFILE_SAMPLE_UPDATE
3637      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3638       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3639   /* Force the compiler not move sample-profiling instrumentation
3640      beyond this point; this way the actual user code is timed.
3641      This is still not perfect, as residuals are materialised before
3642      we arrive here, but should be adequate at least for slow VM
3643      instructions. */
3644   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3645 #endif
3646 #if defined (JITTER_PROFILE_COUNT)
3647   /* Notice that, differently from the code above, this
3648      instrumentation code *can* be reordered freely: as long as a
3649      VM instruction is counted, the count increment can be placed
3650      anyehere.  Let GCC move this code and possibly achieve better
3651      throughput by exploiting instruction-level parallelism and
3652      therefore approximate more closely a non-profiled build. */
3653   JITTER_PROFILE_COUNT_UPDATE
3654      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3655       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3656 #endif
3657 
3658 /* User-specified code, instruction-beginning-c part: beginning. */
3659 
3660 
3661 /* User-specified code, instruction-beginning-c part: end */
3662 
3663 
3664     /* User code for at-depth-to-register/n3/%rR . */
3665 
3666     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
3667     // unsafe at-depth operations.
3668     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
3669 
3670     /* End of the user code for at-depth-to-register/n3/%rR . */
3671 
3672 /* User-specified code, instruction-end-c part: beginning. */
3673 
3674 
3675 /* User-specified code, instruction-end-c part: end */
3676 
3677     /* Undefine the at-depth-to-register/n3/%rR argument macros so they can't be used
3678        by mistake in the instruction body coming next. */
3679 #   undef JITTER_SLOW_REGISTER_OFFSET0
3680 #   undef JITTER_ARG0
3681 #   undef JITTER_ARGN0
3682 #   undef JITTER_ARGU0
3683 #   undef JITTER_ARGP0
3684 #   undef JITTER_ARGF0
3685 #   undef JITTER_SLOW_REGISTER_OFFSET1
3686 #   undef JITTER_ARG1
3687 #   undef JITTER_ARGN1
3688 #   undef JITTER_ARGU1
3689 #   undef JITTER_ARGP1
3690 #   undef JITTER_ARGF1
3691 
3692 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3693 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3694 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3695 
3696   }
3697  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n3/%rR, at_mdepth_mto_mregister__n3___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3698 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3699 
3700   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n4/%rR, at_mdepth_mto_mregister__n4___rrR, cold)
3701   {
3702     /* This specialized instruction is not a replacement. */
3703 #   undef JITTER_BRANCH_FAST
3704 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3705 #   undef JITTER_BRANCH_FAST_IF_ZERO
3706 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3707 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3708 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3709 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3710 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3711 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3712 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3713 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3714 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3715 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3716 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3717 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3718 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3719 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3720 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3721 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3722 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3723 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3724 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3725 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3726 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3727 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3728 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3729 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3730 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3731 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3732 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3733 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3734 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3735 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3736 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3737 #   undef JITTER_BRANCH_FAST_IF_AND
3738 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3739 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3740 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3741 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3742 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3743 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3744 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3745 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3746 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3747 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3748 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3749 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3750 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3751 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3752 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3753 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3754 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3755 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3756 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3757 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3758 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3759 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3760 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3761 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3762 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3763 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3764 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3765 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3766 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3767 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       11
3768 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n4/%rR
3769 
3770 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n4___rrR
3771 
3772   /* The residual arity for this instruction does not depend on fast labels. */
3773   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
3774 
3775     /* The 0th argument is a nonresidual literal. */
3776 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
3777 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
3778 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
3779 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
3780 #   define JITTER_ARGF0 JITTER_ARGP0
3781 
3782     /* The 1th argument is a slow (therefore residual, passed as an offset)
3783         register. */
3784   /* Define a macro expanding to the slow register offset. */
3785 #if defined(JITTER_DISPATCH_NO_THREADING)
3786 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
3787 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
3788 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
3789 #else
3790 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
3791 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
3792   /* Define a macro expanding to an l-value for the VM register content. */
3793 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
3794 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
3795 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
3796 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
3797 #   define JITTER_ARGF1 JITTER_ARGP1
3798 
3799 
3800 #if defined (JITTER_PROFILE_SAMPLE)
3801   JITTER_PROFILE_SAMPLE_UPDATE
3802      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3803       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3804   /* Force the compiler not move sample-profiling instrumentation
3805      beyond this point; this way the actual user code is timed.
3806      This is still not perfect, as residuals are materialised before
3807      we arrive here, but should be adequate at least for slow VM
3808      instructions. */
3809   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3810 #endif
3811 #if defined (JITTER_PROFILE_COUNT)
3812   /* Notice that, differently from the code above, this
3813      instrumentation code *can* be reordered freely: as long as a
3814      VM instruction is counted, the count increment can be placed
3815      anyehere.  Let GCC move this code and possibly achieve better
3816      throughput by exploiting instruction-level parallelism and
3817      therefore approximate more closely a non-profiled build. */
3818   JITTER_PROFILE_COUNT_UPDATE
3819      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3820       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3821 #endif
3822 
3823 /* User-specified code, instruction-beginning-c part: beginning. */
3824 
3825 
3826 /* User-specified code, instruction-beginning-c part: end */
3827 
3828 
3829     /* User code for at-depth-to-register/n4/%rR . */
3830 
3831     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
3832     // unsafe at-depth operations.
3833     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
3834 
3835     /* End of the user code for at-depth-to-register/n4/%rR . */
3836 
3837 /* User-specified code, instruction-end-c part: beginning. */
3838 
3839 
3840 /* User-specified code, instruction-end-c part: end */
3841 
3842     /* Undefine the at-depth-to-register/n4/%rR argument macros so they can't be used
3843        by mistake in the instruction body coming next. */
3844 #   undef JITTER_SLOW_REGISTER_OFFSET0
3845 #   undef JITTER_ARG0
3846 #   undef JITTER_ARGN0
3847 #   undef JITTER_ARGU0
3848 #   undef JITTER_ARGP0
3849 #   undef JITTER_ARGF0
3850 #   undef JITTER_SLOW_REGISTER_OFFSET1
3851 #   undef JITTER_ARG1
3852 #   undef JITTER_ARGN1
3853 #   undef JITTER_ARGU1
3854 #   undef JITTER_ARGP1
3855 #   undef JITTER_ARGF1
3856 
3857 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
3858 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
3859 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
3860 
3861   }
3862  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n4/%rR, at_mdepth_mto_mregister__n4___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
3863 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
3864 
3865   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n5/%rR, at_mdepth_mto_mregister__n5___rrR, cold)
3866   {
3867     /* This specialized instruction is not a replacement. */
3868 #   undef JITTER_BRANCH_FAST
3869 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
3870 #   undef JITTER_BRANCH_FAST_IF_ZERO
3871 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
3872 #   undef JITTER_BRANCH_FAST_IF_NONZERO
3873 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
3874 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
3875 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
3876 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
3877 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
3878 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
3879 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
3880 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
3881 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
3882 #   undef JITTER_BRANCH_FAST_IF_EQUAL
3883 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
3884 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
3885 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
3886 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
3887 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
3888 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3889 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
3890 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3891 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
3892 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3893 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
3894 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3895 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
3896 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3897 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
3898 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3899 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
3900 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3901 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
3902 #   undef JITTER_BRANCH_FAST_IF_AND
3903 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
3904 #   undef JITTER_BRANCH_FAST_IF_NOTAND
3905 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
3906 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3907 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
3908 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3909 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
3910 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3911 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
3912 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3913 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
3914 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3915 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
3916 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3917 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
3918 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3919 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
3920 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3921 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
3922 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3923 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
3924 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3925 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
3926 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3927 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
3928 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3929 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
3930 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3931 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
3932 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       12
3933 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n5/%rR
3934 
3935 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n5___rrR
3936 
3937   /* The residual arity for this instruction does not depend on fast labels. */
3938   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
3939 
3940     /* The 0th argument is a nonresidual literal. */
3941 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
3942 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
3943 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
3944 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
3945 #   define JITTER_ARGF0 JITTER_ARGP0
3946 
3947     /* The 1th argument is a slow (therefore residual, passed as an offset)
3948         register. */
3949   /* Define a macro expanding to the slow register offset. */
3950 #if defined(JITTER_DISPATCH_NO_THREADING)
3951 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
3952 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
3953 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
3954 #else
3955 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
3956 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
3957   /* Define a macro expanding to an l-value for the VM register content. */
3958 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
3959 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
3960 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
3961 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
3962 #   define JITTER_ARGF1 JITTER_ARGP1
3963 
3964 
3965 #if defined (JITTER_PROFILE_SAMPLE)
3966   JITTER_PROFILE_SAMPLE_UPDATE
3967      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3968       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3969   /* Force the compiler not move sample-profiling instrumentation
3970      beyond this point; this way the actual user code is timed.
3971      This is still not perfect, as residuals are materialised before
3972      we arrive here, but should be adequate at least for slow VM
3973      instructions. */
3974   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
3975 #endif
3976 #if defined (JITTER_PROFILE_COUNT)
3977   /* Notice that, differently from the code above, this
3978      instrumentation code *can* be reordered freely: as long as a
3979      VM instruction is counted, the count increment can be placed
3980      anyehere.  Let GCC move this code and possibly achieve better
3981      throughput by exploiting instruction-level parallelism and
3982      therefore approximate more closely a non-profiled build. */
3983   JITTER_PROFILE_COUNT_UPDATE
3984      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
3985       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
3986 #endif
3987 
3988 /* User-specified code, instruction-beginning-c part: beginning. */
3989 
3990 
3991 /* User-specified code, instruction-beginning-c part: end */
3992 
3993 
3994     /* User code for at-depth-to-register/n5/%rR . */
3995 
3996     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
3997     // unsafe at-depth operations.
3998     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
3999 
4000     /* End of the user code for at-depth-to-register/n5/%rR . */
4001 
4002 /* User-specified code, instruction-end-c part: beginning. */
4003 
4004 
4005 /* User-specified code, instruction-end-c part: end */
4006 
4007     /* Undefine the at-depth-to-register/n5/%rR argument macros so they can't be used
4008        by mistake in the instruction body coming next. */
4009 #   undef JITTER_SLOW_REGISTER_OFFSET0
4010 #   undef JITTER_ARG0
4011 #   undef JITTER_ARGN0
4012 #   undef JITTER_ARGU0
4013 #   undef JITTER_ARGP0
4014 #   undef JITTER_ARGF0
4015 #   undef JITTER_SLOW_REGISTER_OFFSET1
4016 #   undef JITTER_ARG1
4017 #   undef JITTER_ARGN1
4018 #   undef JITTER_ARGU1
4019 #   undef JITTER_ARGP1
4020 #   undef JITTER_ARGF1
4021 
4022 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4023 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4024 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4025 
4026   }
4027  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n5/%rR, at_mdepth_mto_mregister__n5___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4028 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4029 
4030   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n6/%rR, at_mdepth_mto_mregister__n6___rrR, cold)
4031   {
4032     /* This specialized instruction is not a replacement. */
4033 #   undef JITTER_BRANCH_FAST
4034 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4035 #   undef JITTER_BRANCH_FAST_IF_ZERO
4036 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4037 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4038 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4039 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4040 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4041 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4042 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4043 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4044 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4045 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4046 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4047 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4048 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4049 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4050 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4051 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4052 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4053 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4054 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4055 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4056 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4057 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4058 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4059 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4060 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4061 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4062 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4063 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4064 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4065 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4066 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4067 #   undef JITTER_BRANCH_FAST_IF_AND
4068 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4069 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4070 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4071 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4072 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4073 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4074 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4075 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4076 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4077 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4078 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4079 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4080 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4081 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4082 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4083 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4084 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4085 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4086 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4087 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4088 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4089 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4090 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4091 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4092 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4093 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4094 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4095 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4096 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4097 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       13
4098 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n6/%rR
4099 
4100 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n6___rrR
4101 
4102   /* The residual arity for this instruction does not depend on fast labels. */
4103   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
4104 
4105     /* The 0th argument is a nonresidual literal. */
4106 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
4107 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
4108 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
4109 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
4110 #   define JITTER_ARGF0 JITTER_ARGP0
4111 
4112     /* The 1th argument is a slow (therefore residual, passed as an offset)
4113         register. */
4114   /* Define a macro expanding to the slow register offset. */
4115 #if defined(JITTER_DISPATCH_NO_THREADING)
4116 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
4117 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
4118 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
4119 #else
4120 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
4121 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
4122   /* Define a macro expanding to an l-value for the VM register content. */
4123 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
4124 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
4125 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
4126 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
4127 #   define JITTER_ARGF1 JITTER_ARGP1
4128 
4129 
4130 #if defined (JITTER_PROFILE_SAMPLE)
4131   JITTER_PROFILE_SAMPLE_UPDATE
4132      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4133       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4134   /* Force the compiler not move sample-profiling instrumentation
4135      beyond this point; this way the actual user code is timed.
4136      This is still not perfect, as residuals are materialised before
4137      we arrive here, but should be adequate at least for slow VM
4138      instructions. */
4139   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4140 #endif
4141 #if defined (JITTER_PROFILE_COUNT)
4142   /* Notice that, differently from the code above, this
4143      instrumentation code *can* be reordered freely: as long as a
4144      VM instruction is counted, the count increment can be placed
4145      anyehere.  Let GCC move this code and possibly achieve better
4146      throughput by exploiting instruction-level parallelism and
4147      therefore approximate more closely a non-profiled build. */
4148   JITTER_PROFILE_COUNT_UPDATE
4149      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4150       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4151 #endif
4152 
4153 /* User-specified code, instruction-beginning-c part: beginning. */
4154 
4155 
4156 /* User-specified code, instruction-beginning-c part: end */
4157 
4158 
4159     /* User code for at-depth-to-register/n6/%rR . */
4160 
4161     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
4162     // unsafe at-depth operations.
4163     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
4164 
4165     /* End of the user code for at-depth-to-register/n6/%rR . */
4166 
4167 /* User-specified code, instruction-end-c part: beginning. */
4168 
4169 
4170 /* User-specified code, instruction-end-c part: end */
4171 
4172     /* Undefine the at-depth-to-register/n6/%rR argument macros so they can't be used
4173        by mistake in the instruction body coming next. */
4174 #   undef JITTER_SLOW_REGISTER_OFFSET0
4175 #   undef JITTER_ARG0
4176 #   undef JITTER_ARGN0
4177 #   undef JITTER_ARGU0
4178 #   undef JITTER_ARGP0
4179 #   undef JITTER_ARGF0
4180 #   undef JITTER_SLOW_REGISTER_OFFSET1
4181 #   undef JITTER_ARG1
4182 #   undef JITTER_ARGN1
4183 #   undef JITTER_ARGU1
4184 #   undef JITTER_ARGP1
4185 #   undef JITTER_ARGF1
4186 
4187 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4188 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4189 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4190 
4191   }
4192  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n6/%rR, at_mdepth_mto_mregister__n6___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4193 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4194 
4195   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n7/%rR, at_mdepth_mto_mregister__n7___rrR, cold)
4196   {
4197     /* This specialized instruction is not a replacement. */
4198 #   undef JITTER_BRANCH_FAST
4199 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4200 #   undef JITTER_BRANCH_FAST_IF_ZERO
4201 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4202 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4203 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4204 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4205 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4206 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4207 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4208 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4209 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4210 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4211 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4212 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4213 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4214 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4215 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4216 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4217 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4218 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4219 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4220 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4221 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4222 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4223 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4224 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4225 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4226 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4227 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4228 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4229 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4230 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4231 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4232 #   undef JITTER_BRANCH_FAST_IF_AND
4233 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4234 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4235 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4236 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4237 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4238 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4239 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4240 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4241 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4242 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4243 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4244 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4245 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4246 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4247 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4248 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4249 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4250 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4251 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4252 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4253 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4254 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4255 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4256 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4257 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4258 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4259 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4260 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4261 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4262 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       14
4263 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n7/%rR
4264 
4265 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n7___rrR
4266 
4267   /* The residual arity for this instruction does not depend on fast labels. */
4268   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
4269 
4270     /* The 0th argument is a nonresidual literal. */
4271 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
4272 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
4273 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
4274 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
4275 #   define JITTER_ARGF0 JITTER_ARGP0
4276 
4277     /* The 1th argument is a slow (therefore residual, passed as an offset)
4278         register. */
4279   /* Define a macro expanding to the slow register offset. */
4280 #if defined(JITTER_DISPATCH_NO_THREADING)
4281 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
4282 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
4283 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
4284 #else
4285 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
4286 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
4287   /* Define a macro expanding to an l-value for the VM register content. */
4288 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
4289 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
4290 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
4291 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
4292 #   define JITTER_ARGF1 JITTER_ARGP1
4293 
4294 
4295 #if defined (JITTER_PROFILE_SAMPLE)
4296   JITTER_PROFILE_SAMPLE_UPDATE
4297      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4298       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4299   /* Force the compiler not move sample-profiling instrumentation
4300      beyond this point; this way the actual user code is timed.
4301      This is still not perfect, as residuals are materialised before
4302      we arrive here, but should be adequate at least for slow VM
4303      instructions. */
4304   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4305 #endif
4306 #if defined (JITTER_PROFILE_COUNT)
4307   /* Notice that, differently from the code above, this
4308      instrumentation code *can* be reordered freely: as long as a
4309      VM instruction is counted, the count increment can be placed
4310      anyehere.  Let GCC move this code and possibly achieve better
4311      throughput by exploiting instruction-level parallelism and
4312      therefore approximate more closely a non-profiled build. */
4313   JITTER_PROFILE_COUNT_UPDATE
4314      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4315       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4316 #endif
4317 
4318 /* User-specified code, instruction-beginning-c part: beginning. */
4319 
4320 
4321 /* User-specified code, instruction-beginning-c part: end */
4322 
4323 
4324     /* User code for at-depth-to-register/n7/%rR . */
4325 
4326     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
4327     // unsafe at-depth operations.
4328     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
4329 
4330     /* End of the user code for at-depth-to-register/n7/%rR . */
4331 
4332 /* User-specified code, instruction-end-c part: beginning. */
4333 
4334 
4335 /* User-specified code, instruction-end-c part: end */
4336 
4337     /* Undefine the at-depth-to-register/n7/%rR argument macros so they can't be used
4338        by mistake in the instruction body coming next. */
4339 #   undef JITTER_SLOW_REGISTER_OFFSET0
4340 #   undef JITTER_ARG0
4341 #   undef JITTER_ARGN0
4342 #   undef JITTER_ARGU0
4343 #   undef JITTER_ARGP0
4344 #   undef JITTER_ARGF0
4345 #   undef JITTER_SLOW_REGISTER_OFFSET1
4346 #   undef JITTER_ARG1
4347 #   undef JITTER_ARGN1
4348 #   undef JITTER_ARGU1
4349 #   undef JITTER_ARGP1
4350 #   undef JITTER_ARGF1
4351 
4352 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4353 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4354 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4355 
4356   }
4357  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n7/%rR, at_mdepth_mto_mregister__n7___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4358 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4359 
4360   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n8/%rR, at_mdepth_mto_mregister__n8___rrR, cold)
4361   {
4362     /* This specialized instruction is not a replacement. */
4363 #   undef JITTER_BRANCH_FAST
4364 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4365 #   undef JITTER_BRANCH_FAST_IF_ZERO
4366 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4367 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4368 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4369 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4370 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4371 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4372 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4373 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4374 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4375 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4376 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4377 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4378 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4379 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4380 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4381 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4382 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4383 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4384 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4385 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4386 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4387 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4388 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4389 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4390 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4391 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4392 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4393 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4394 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4395 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4396 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4397 #   undef JITTER_BRANCH_FAST_IF_AND
4398 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4399 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4400 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4401 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4402 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4403 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4404 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4405 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4406 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4407 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4408 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4409 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4410 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4411 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4412 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4413 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4414 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4415 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4416 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4417 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4418 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4419 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4420 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4421 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4422 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4423 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4424 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4425 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4426 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4427 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       15
4428 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n8/%rR
4429 
4430 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n8___rrR
4431 
4432   /* The residual arity for this instruction does not depend on fast labels. */
4433   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
4434 
4435     /* The 0th argument is a nonresidual literal. */
4436 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
4437 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
4438 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
4439 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
4440 #   define JITTER_ARGF0 JITTER_ARGP0
4441 
4442     /* The 1th argument is a slow (therefore residual, passed as an offset)
4443         register. */
4444   /* Define a macro expanding to the slow register offset. */
4445 #if defined(JITTER_DISPATCH_NO_THREADING)
4446 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
4447 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
4448 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
4449 #else
4450 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
4451 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
4452   /* Define a macro expanding to an l-value for the VM register content. */
4453 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
4454 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
4455 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
4456 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
4457 #   define JITTER_ARGF1 JITTER_ARGP1
4458 
4459 
4460 #if defined (JITTER_PROFILE_SAMPLE)
4461   JITTER_PROFILE_SAMPLE_UPDATE
4462      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4463       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4464   /* Force the compiler not move sample-profiling instrumentation
4465      beyond this point; this way the actual user code is timed.
4466      This is still not perfect, as residuals are materialised before
4467      we arrive here, but should be adequate at least for slow VM
4468      instructions. */
4469   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4470 #endif
4471 #if defined (JITTER_PROFILE_COUNT)
4472   /* Notice that, differently from the code above, this
4473      instrumentation code *can* be reordered freely: as long as a
4474      VM instruction is counted, the count increment can be placed
4475      anyehere.  Let GCC move this code and possibly achieve better
4476      throughput by exploiting instruction-level parallelism and
4477      therefore approximate more closely a non-profiled build. */
4478   JITTER_PROFILE_COUNT_UPDATE
4479      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4480       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4481 #endif
4482 
4483 /* User-specified code, instruction-beginning-c part: beginning. */
4484 
4485 
4486 /* User-specified code, instruction-beginning-c part: end */
4487 
4488 
4489     /* User code for at-depth-to-register/n8/%rR . */
4490 
4491     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
4492     // unsafe at-depth operations.
4493     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
4494 
4495     /* End of the user code for at-depth-to-register/n8/%rR . */
4496 
4497 /* User-specified code, instruction-end-c part: beginning. */
4498 
4499 
4500 /* User-specified code, instruction-end-c part: end */
4501 
4502     /* Undefine the at-depth-to-register/n8/%rR argument macros so they can't be used
4503        by mistake in the instruction body coming next. */
4504 #   undef JITTER_SLOW_REGISTER_OFFSET0
4505 #   undef JITTER_ARG0
4506 #   undef JITTER_ARGN0
4507 #   undef JITTER_ARGU0
4508 #   undef JITTER_ARGP0
4509 #   undef JITTER_ARGF0
4510 #   undef JITTER_SLOW_REGISTER_OFFSET1
4511 #   undef JITTER_ARG1
4512 #   undef JITTER_ARGN1
4513 #   undef JITTER_ARGU1
4514 #   undef JITTER_ARGP1
4515 #   undef JITTER_ARGF1
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_(at-depth-to-register/n8/%rR, at_mdepth_mto_mregister__n8___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4523 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4524 
4525   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n9/%rR, at_mdepth_mto_mregister__n9___rrR, cold)
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       16
4593 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n9/%rR
4594 
4595 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n9___rrR
4596 
4597   /* The residual arity for this instruction does not depend on fast labels. */
4598   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
4599 
4600     /* The 0th argument is a nonresidual literal. */
4601 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
4602 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
4603 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
4604 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
4605 #   define JITTER_ARGF0 JITTER_ARGP0
4606 
4607     /* The 1th argument is a slow (therefore residual, passed as an offset)
4608         register. */
4609   /* Define a macro expanding to the slow register offset. */
4610 #if defined(JITTER_DISPATCH_NO_THREADING)
4611 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
4612 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
4613 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
4614 #else
4615 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
4616 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
4617   /* Define a macro expanding to an l-value for the VM register content. */
4618 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
4619 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
4620 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
4621 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
4622 #   define JITTER_ARGF1 JITTER_ARGP1
4623 
4624 
4625 #if defined (JITTER_PROFILE_SAMPLE)
4626   JITTER_PROFILE_SAMPLE_UPDATE
4627      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4628       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4629   /* Force the compiler not move sample-profiling instrumentation
4630      beyond this point; this way the actual user code is timed.
4631      This is still not perfect, as residuals are materialised before
4632      we arrive here, but should be adequate at least for slow VM
4633      instructions. */
4634   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4635 #endif
4636 #if defined (JITTER_PROFILE_COUNT)
4637   /* Notice that, differently from the code above, this
4638      instrumentation code *can* be reordered freely: as long as a
4639      VM instruction is counted, the count increment can be placed
4640      anyehere.  Let GCC move this code and possibly achieve better
4641      throughput by exploiting instruction-level parallelism and
4642      therefore approximate more closely a non-profiled build. */
4643   JITTER_PROFILE_COUNT_UPDATE
4644      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4645       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4646 #endif
4647 
4648 /* User-specified code, instruction-beginning-c part: beginning. */
4649 
4650 
4651 /* User-specified code, instruction-beginning-c part: end */
4652 
4653 
4654     /* User code for at-depth-to-register/n9/%rR . */
4655 
4656     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
4657     // unsafe at-depth operations.
4658     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
4659 
4660     /* End of the user code for at-depth-to-register/n9/%rR . */
4661 
4662 /* User-specified code, instruction-end-c part: beginning. */
4663 
4664 
4665 /* User-specified code, instruction-end-c part: end */
4666 
4667     /* Undefine the at-depth-to-register/n9/%rR argument macros so they can't be used
4668        by mistake in the instruction body coming next. */
4669 #   undef JITTER_SLOW_REGISTER_OFFSET0
4670 #   undef JITTER_ARG0
4671 #   undef JITTER_ARGN0
4672 #   undef JITTER_ARGU0
4673 #   undef JITTER_ARGP0
4674 #   undef JITTER_ARGF0
4675 #   undef JITTER_SLOW_REGISTER_OFFSET1
4676 #   undef JITTER_ARG1
4677 #   undef JITTER_ARGN1
4678 #   undef JITTER_ARGU1
4679 #   undef JITTER_ARGP1
4680 #   undef JITTER_ARGF1
4681 
4682 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4683 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4684 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4685 
4686   }
4687  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n9/%rR, at_mdepth_mto_mregister__n9___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4688 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4689 
4690   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/n10/%rR, at_mdepth_mto_mregister__n10___rrR, cold)
4691   {
4692     /* This specialized instruction is not a replacement. */
4693 #   undef JITTER_BRANCH_FAST
4694 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4695 #   undef JITTER_BRANCH_FAST_IF_ZERO
4696 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4697 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4698 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4699 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4700 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4701 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4702 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4703 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4704 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4705 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4706 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4707 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4708 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4709 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4710 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4711 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4712 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4713 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4714 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4715 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4716 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4717 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4718 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4719 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4720 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4721 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4722 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4723 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4724 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4725 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4726 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4727 #   undef JITTER_BRANCH_FAST_IF_AND
4728 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4729 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4730 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4731 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4732 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4733 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4734 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4735 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4736 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4737 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4738 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4739 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4740 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4741 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4742 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4743 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4744 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4745 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4746 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4747 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4748 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4749 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4750 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4751 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4752 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4753 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4754 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4755 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4756 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4757 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       17
4758 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/n10/%rR
4759 
4760 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__n10___rrR
4761 
4762   /* The residual arity for this instruction does not depend on fast labels. */
4763   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
4764 
4765     /* The 0th argument is a nonresidual literal. */
4766 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
4767 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
4768 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
4769 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
4770 #   define JITTER_ARGF0 JITTER_ARGP0
4771 
4772     /* The 1th argument is a slow (therefore residual, passed as an offset)
4773         register. */
4774   /* Define a macro expanding to the slow register offset. */
4775 #if defined(JITTER_DISPATCH_NO_THREADING)
4776 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
4777 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
4778 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[0]).fixnum)
4779 #else
4780 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
4781 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
4782   /* Define a macro expanding to an l-value for the VM register content. */
4783 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
4784 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
4785 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
4786 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
4787 #   define JITTER_ARGF1 JITTER_ARGP1
4788 
4789 
4790 #if defined (JITTER_PROFILE_SAMPLE)
4791   JITTER_PROFILE_SAMPLE_UPDATE
4792      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4793       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4794   /* Force the compiler not move sample-profiling instrumentation
4795      beyond this point; this way the actual user code is timed.
4796      This is still not perfect, as residuals are materialised before
4797      we arrive here, but should be adequate at least for slow VM
4798      instructions. */
4799   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4800 #endif
4801 #if defined (JITTER_PROFILE_COUNT)
4802   /* Notice that, differently from the code above, this
4803      instrumentation code *can* be reordered freely: as long as a
4804      VM instruction is counted, the count increment can be placed
4805      anyehere.  Let GCC move this code and possibly achieve better
4806      throughput by exploiting instruction-level parallelism and
4807      therefore approximate more closely a non-profiled build. */
4808   JITTER_PROFILE_COUNT_UPDATE
4809      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4810       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4811 #endif
4812 
4813 /* User-specified code, instruction-beginning-c part: beginning. */
4814 
4815 
4816 /* User-specified code, instruction-beginning-c part: end */
4817 
4818 
4819     /* User code for at-depth-to-register/n10/%rR . */
4820 
4821     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
4822     // unsafe at-depth operations.
4823     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
4824 
4825     /* End of the user code for at-depth-to-register/n10/%rR . */
4826 
4827 /* User-specified code, instruction-end-c part: beginning. */
4828 
4829 
4830 /* User-specified code, instruction-end-c part: end */
4831 
4832     /* Undefine the at-depth-to-register/n10/%rR argument macros so they can't be used
4833        by mistake in the instruction body coming next. */
4834 #   undef JITTER_SLOW_REGISTER_OFFSET0
4835 #   undef JITTER_ARG0
4836 #   undef JITTER_ARGN0
4837 #   undef JITTER_ARGU0
4838 #   undef JITTER_ARGP0
4839 #   undef JITTER_ARGF0
4840 #   undef JITTER_SLOW_REGISTER_OFFSET1
4841 #   undef JITTER_ARG1
4842 #   undef JITTER_ARGN1
4843 #   undef JITTER_ARGU1
4844 #   undef JITTER_ARGP1
4845 #   undef JITTER_ARGF1
4846 
4847 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
4848 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
4849 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
4850 
4851   }
4852  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/n10/%rR, at_mdepth_mto_mregister__n10___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
4853 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
4854 
4855   JITTER_INSTRUCTION_PROLOG_(at-depth-to-register/nR/%rR, at_mdepth_mto_mregister__nR___rrR, cold)
4856   {
4857     /* This specialized instruction is not a replacement. */
4858 #   undef JITTER_BRANCH_FAST
4859 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
4860 #   undef JITTER_BRANCH_FAST_IF_ZERO
4861 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
4862 #   undef JITTER_BRANCH_FAST_IF_NONZERO
4863 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
4864 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
4865 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
4866 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
4867 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
4868 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
4869 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
4870 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
4871 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
4872 #   undef JITTER_BRANCH_FAST_IF_EQUAL
4873 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
4874 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
4875 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
4876 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
4877 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
4878 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4879 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
4880 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4881 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
4882 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4883 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
4884 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4885 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
4886 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4887 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
4888 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4889 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
4890 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4891 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
4892 #   undef JITTER_BRANCH_FAST_IF_AND
4893 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
4894 #   undef JITTER_BRANCH_FAST_IF_NOTAND
4895 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
4896 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4897 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
4898 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4899 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
4900 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4901 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
4902 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4903 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
4904 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4905 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
4906 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4907 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
4908 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4909 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
4910 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4911 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
4912 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4913 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
4914 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4915 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
4916 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4917 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
4918 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4919 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
4920 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4921 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
4922 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       18
4923 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         at-depth-to-register/nR/%rR
4924 
4925 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME at_mdepth_mto_mregister__nR___rrR
4926 
4927   /* The residual arity for this instruction does not depend on fast labels. */
4928   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
4929 
4930     /* The 0th argument is a residual literal. */
4931 #if defined(JITTER_DISPATCH_NO_THREADING)
4932 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
4933     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
4934 #elif defined (JITTER_REPLICATE)
4935 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
4936 #else
4937 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
4938 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
4939 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
4940 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
4941 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
4942 #   define JITTER_ARGF0 JITTER_ARGP0
4943 
4944     /* The 1th argument is a slow (therefore residual, passed as an offset)
4945         register. */
4946   /* Define a macro expanding to the slow register offset. */
4947 #if defined(JITTER_DISPATCH_NO_THREADING)
4948 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
4949 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
4950 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
4951 #else
4952 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
4953 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
4954   /* Define a macro expanding to an l-value for the VM register content. */
4955 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
4956 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
4957 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
4958 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
4959 #   define JITTER_ARGF1 JITTER_ARGP1
4960 
4961 
4962 #if defined (JITTER_PROFILE_SAMPLE)
4963   JITTER_PROFILE_SAMPLE_UPDATE
4964      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4965       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4966   /* Force the compiler not move sample-profiling instrumentation
4967      beyond this point; this way the actual user code is timed.
4968      This is still not perfect, as residuals are materialised before
4969      we arrive here, but should be adequate at least for slow VM
4970      instructions. */
4971   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
4972 #endif
4973 #if defined (JITTER_PROFILE_COUNT)
4974   /* Notice that, differently from the code above, this
4975      instrumentation code *can* be reordered freely: as long as a
4976      VM instruction is counted, the count increment can be placed
4977      anyehere.  Let GCC move this code and possibly achieve better
4978      throughput by exploiting instruction-level parallelism and
4979      therefore approximate more closely a non-profiled build. */
4980   JITTER_PROFILE_COUNT_UPDATE
4981      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
4982       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
4983 #endif
4984 
4985 /* User-specified code, instruction-beginning-c part: beginning. */
4986 
4987 
4988 /* User-specified code, instruction-beginning-c part: end */
4989 
4990 
4991     /* User code for at-depth-to-register/nR/%rR . */
4992 
4993     // FIXME: replace with JITTER_AT_DEPTH_UNSAFE_MAINSTACK after I implement
4994     // unsafe at-depth operations.
4995     JITTER_ARG1 = JITTER_AT_DEPTH_MAINSTACK(JITTER_ARGN0);
4996 
4997     /* End of the user code for at-depth-to-register/nR/%rR . */
4998 
4999 /* User-specified code, instruction-end-c part: beginning. */
5000 
5001 
5002 /* User-specified code, instruction-end-c part: end */
5003 
5004     /* Undefine the at-depth-to-register/nR/%rR argument macros so they can't be used
5005        by mistake in the instruction body coming next. */
5006 #   undef JITTER_SLOW_REGISTER_OFFSET0
5007 #   undef JITTER_ARG0
5008 #   undef JITTER_ARGN0
5009 #   undef JITTER_ARGU0
5010 #   undef JITTER_ARGP0
5011 #   undef JITTER_ARGF0
5012 #   undef JITTER_SLOW_REGISTER_OFFSET1
5013 #   undef JITTER_ARG1
5014 #   undef JITTER_ARGN1
5015 #   undef JITTER_ARGU1
5016 #   undef JITTER_ARGP1
5017 #   undef JITTER_ARGF1
5018 
5019 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5020 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5021 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5022 
5023   }
5024  JITTER_INSTRUCTION_EPILOG_(at-depth-to-register/nR/%rR, at_mdepth_mto_mregister__nR___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5025 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5026 
5027   JITTER_INSTRUCTION_PROLOG_(branch/fR, branch__fR, hot)
5028   {
5029     /* This specialized instruction is not a replacement. */
5030 #   undef JITTER_BRANCH_FAST
5031 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5032 #   undef JITTER_BRANCH_FAST_IF_ZERO
5033 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5034 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5035 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5036 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5037 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5038 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5039 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5040 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5041 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5042 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5043 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5044 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5045 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5046 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5047 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5048 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5049 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5050 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5051 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5052 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5053 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5054 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5055 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5056 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5057 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5058 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5059 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5060 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5061 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5062 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5063 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5064 #   undef JITTER_BRANCH_FAST_IF_AND
5065 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5066 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5067 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5068 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5069 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5070 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5071 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5072 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5073 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5074 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5075 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5076 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5077 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5078 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5079 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5080 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5081 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5082 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5083 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5084 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5085 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5086 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5087 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5088 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5089 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5090 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5091 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5092 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5093 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5094 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       19
5095 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch/fR
5096 
5097 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch__fR
5098 
5099   /* The residual arity varies depending on whether we have fast labels. */
5100 #ifdef JITTER_HAVE_PATCH_IN
5101   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5102 #else
5103   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
5104 #endif // #ifdef JITTER_HAVE_PATCH_IN
5105 
5106   /* Define argument-access macros for branch/fR . */
5107 #ifdef JITTER_HAVE_PATCH_IN
5108   /* Define argument-access macros assuming that fast branches are enabled. */
5109     /* The 0th argument is a "residual" fast label.  Define its
5110        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5111        so that at replication time we know what instruction address to patch in. */
5112 #   define JITTER_ARGF0 0
5113     /* JITTER_ARG0 is intentionally not defined for a fast label. */
5114 
5115 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5116 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5117 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5118 
5119 #else
5120   /* Define argument-access macros assuming that fast branches are disabled. */
5121 #if defined(JITTER_DISPATCH_NO_THREADING)
5122 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
5123     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
5124 #elif defined (JITTER_REPLICATE)
5125 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
5126 #else
5127 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
5128 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5129 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5130 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5131 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5132 #   define JITTER_ARGF0 JITTER_ARGP0
5133 
5134 # endif // #ifdef JITTER_HAVE_PATCH_IN
5135 
5136 #if defined (JITTER_PROFILE_SAMPLE)
5137   JITTER_PROFILE_SAMPLE_UPDATE
5138      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5139       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5140   /* Force the compiler not move sample-profiling instrumentation
5141      beyond this point; this way the actual user code is timed.
5142      This is still not perfect, as residuals are materialised before
5143      we arrive here, but should be adequate at least for slow VM
5144      instructions. */
5145   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5146 #endif
5147 #if defined (JITTER_PROFILE_COUNT)
5148   /* Notice that, differently from the code above, this
5149      instrumentation code *can* be reordered freely: as long as a
5150      VM instruction is counted, the count increment can be placed
5151      anyehere.  Let GCC move this code and possibly achieve better
5152      throughput by exploiting instruction-level parallelism and
5153      therefore approximate more closely a non-profiled build. */
5154   JITTER_PROFILE_COUNT_UPDATE
5155      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5156       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5157 #endif
5158 
5159 /* User-specified code, instruction-beginning-c part: beginning. */
5160 
5161 
5162 /* User-specified code, instruction-beginning-c part: end */
5163 
5164 
5165     /* User code for branch/fR . */
5166 
5167     JITTER_BRANCH_FAST(JITTER_ARGF0);
5168 
5169     /* End of the user code for branch/fR . */
5170 
5171 /* User-specified code, instruction-end-c part: beginning. */
5172 
5173 
5174 /* User-specified code, instruction-end-c part: end */
5175 
5176     /* Undefine the branch/fR argument macros so they can't be used
5177        by mistake in the instruction body coming next. */
5178 #   undef JITTER_SLOW_REGISTER_OFFSET0
5179 #   undef JITTER_ARG0
5180 #   undef JITTER_ARGN0
5181 #   undef JITTER_ARGU0
5182 #   undef JITTER_ARGP0
5183 #   undef JITTER_ARGF0
5184 
5185 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5186 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5187 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5188 
5189   }
5190  JITTER_INSTRUCTION_EPILOG_(branch/fR, branch__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5191 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5192 
5193   JITTER_INSTRUCTION_PROLOG_(branch-if-false/fR, branch_mif_mfalse__fR, hot)
5194   {
5195     /* This specialized instruction is not a replacement. */
5196 #   undef JITTER_BRANCH_FAST
5197 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5198 #   undef JITTER_BRANCH_FAST_IF_ZERO
5199 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5200 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5201 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5202 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5203 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5204 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5205 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5206 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5207 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5208 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5209 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5210 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5211 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5212 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5213 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5214 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5215 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5216 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5217 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5218 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5219 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5220 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5221 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5222 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5223 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5224 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5225 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5226 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5227 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5228 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5229 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5230 #   undef JITTER_BRANCH_FAST_IF_AND
5231 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5232 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5233 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5234 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5235 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5236 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5237 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5238 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5239 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5240 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5241 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5242 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5243 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5244 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5245 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5246 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5247 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5248 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5249 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5250 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5251 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5252 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5253 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5254 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5255 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5256 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5257 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5258 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5259 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5260 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       20
5261 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-false/fR
5262 
5263 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mfalse__fR
5264 
5265   /* The residual arity varies depending on whether we have fast labels. */
5266 #ifdef JITTER_HAVE_PATCH_IN
5267   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5268 #else
5269   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
5270 #endif // #ifdef JITTER_HAVE_PATCH_IN
5271 
5272   /* Define argument-access macros for branch-if-false/fR . */
5273 #ifdef JITTER_HAVE_PATCH_IN
5274   /* Define argument-access macros assuming that fast branches are enabled. */
5275     /* The 0th argument is a "residual" fast label.  Define its
5276        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5277        so that at replication time we know what instruction address to patch in. */
5278 #   define JITTER_ARGF0 0
5279     /* JITTER_ARG0 is intentionally not defined for a fast label. */
5280 
5281 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5282 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5283 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5284 
5285 #else
5286   /* Define argument-access macros assuming that fast branches are disabled. */
5287 #if defined(JITTER_DISPATCH_NO_THREADING)
5288 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
5289     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
5290 #elif defined (JITTER_REPLICATE)
5291 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
5292 #else
5293 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
5294 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5295 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5296 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5297 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5298 #   define JITTER_ARGF0 JITTER_ARGP0
5299 
5300 # endif // #ifdef JITTER_HAVE_PATCH_IN
5301 
5302 #if defined (JITTER_PROFILE_SAMPLE)
5303   JITTER_PROFILE_SAMPLE_UPDATE
5304      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5305       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5306   /* Force the compiler not move sample-profiling instrumentation
5307      beyond this point; this way the actual user code is timed.
5308      This is still not perfect, as residuals are materialised before
5309      we arrive here, but should be adequate at least for slow VM
5310      instructions. */
5311   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5312 #endif
5313 #if defined (JITTER_PROFILE_COUNT)
5314   /* Notice that, differently from the code above, this
5315      instrumentation code *can* be reordered freely: as long as a
5316      VM instruction is counted, the count increment can be placed
5317      anyehere.  Let GCC move this code and possibly achieve better
5318      throughput by exploiting instruction-level parallelism and
5319      therefore approximate more closely a non-profiled build. */
5320   JITTER_PROFILE_COUNT_UPDATE
5321      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5322       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5323 #endif
5324 
5325 /* User-specified code, instruction-beginning-c part: beginning. */
5326 
5327 
5328 /* User-specified code, instruction-beginning-c part: end */
5329 
5330 
5331     /* User code for branch-if-false/fR . */
5332 
5333     jitterlisp_object top = JITTER_TOP_MAINSTACK();
5334     JITTER_DROP_MAINSTACK();
5335     JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
5336 
5337     /* End of the user code for branch-if-false/fR . */
5338 
5339 /* User-specified code, instruction-end-c part: beginning. */
5340 
5341 
5342 /* User-specified code, instruction-end-c part: end */
5343 
5344     /* Undefine the branch-if-false/fR argument macros so they can't be used
5345        by mistake in the instruction body coming next. */
5346 #   undef JITTER_SLOW_REGISTER_OFFSET0
5347 #   undef JITTER_ARG0
5348 #   undef JITTER_ARGN0
5349 #   undef JITTER_ARGU0
5350 #   undef JITTER_ARGP0
5351 #   undef JITTER_ARGF0
5352 
5353 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5354 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5355 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5356 
5357   }
5358  JITTER_INSTRUCTION_EPILOG_(branch-if-false/fR, branch_mif_mfalse__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5359 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5360 
5361   JITTER_INSTRUCTION_PROLOG_(branch-if-not-less/fR/fR, branch_mif_mnot_mless__fR__fR, hot)
5362   {
5363     /* This specialized instruction is not a replacement. */
5364 #   undef JITTER_BRANCH_FAST
5365 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5366 #   undef JITTER_BRANCH_FAST_IF_ZERO
5367 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5368 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5369 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5370 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5371 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5372 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5373 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5374 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5375 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5376 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5377 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5378 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5379 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5380 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5381 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5382 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5383 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5384 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5385 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5386 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5387 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5388 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5389 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5390 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5391 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5392 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5393 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5394 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5395 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5396 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5397 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5398 #   undef JITTER_BRANCH_FAST_IF_AND
5399 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5400 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5401 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5402 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5403 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5404 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5405 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5406 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5407 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5408 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5409 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5410 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5411 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5412 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5413 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5414 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5415 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5416 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5417 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5418 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5419 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5420 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5421 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5422 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5423 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5424 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5425 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5426 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5427 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5428 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       21
5429 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-not-less/fR/fR
5430 
5431 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mnot_mless__fR__fR
5432 
5433   /* The residual arity varies depending on whether we have fast labels. */
5434 #ifdef JITTER_HAVE_PATCH_IN
5435   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5436 #else
5437   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
5438 #endif // #ifdef JITTER_HAVE_PATCH_IN
5439 
5440   /* Define argument-access macros for branch-if-not-less/fR/fR . */
5441 #ifdef JITTER_HAVE_PATCH_IN
5442   /* Define argument-access macros assuming that fast branches are enabled. */
5443     /* The 0th argument is a "residual" fast label.  Define its
5444        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5445        so that at replication time we know what instruction address to patch in. */
5446 #   define JITTER_ARGF0 0
5447     /* JITTER_ARG0 is intentionally not defined for a fast label. */
5448 
5449 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5450 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5451 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5452 
5453     /* The 1th argument is a "residual" fast label.  Define its
5454        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5455        so that at replication time we know what instruction address to patch in. */
5456 #   define JITTER_ARGF1 1
5457     /* JITTER_ARG1 is intentionally not defined for a fast label. */
5458 
5459 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
5460 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
5461 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
5462 
5463 #else
5464   /* Define argument-access macros assuming that fast branches are disabled. */
5465 #if defined(JITTER_DISPATCH_NO_THREADING)
5466 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
5467     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
5468 #elif defined (JITTER_REPLICATE)
5469 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
5470 #else
5471 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
5472 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5473 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5474 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5475 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5476 #   define JITTER_ARGF0 JITTER_ARGP0
5477 
5478 #if defined(JITTER_DISPATCH_NO_THREADING)
5479 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
5480     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
5481 #elif defined (JITTER_REPLICATE)
5482 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
5483 #else
5484 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
5485 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5486 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
5487 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
5488 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
5489 #   define JITTER_ARGF1 JITTER_ARGP1
5490 
5491 # endif // #ifdef JITTER_HAVE_PATCH_IN
5492 
5493 #if defined (JITTER_PROFILE_SAMPLE)
5494   JITTER_PROFILE_SAMPLE_UPDATE
5495      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5496       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5497   /* Force the compiler not move sample-profiling instrumentation
5498      beyond this point; this way the actual user code is timed.
5499      This is still not perfect, as residuals are materialised before
5500      we arrive here, but should be adequate at least for slow VM
5501      instructions. */
5502   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5503 #endif
5504 #if defined (JITTER_PROFILE_COUNT)
5505   /* Notice that, differently from the code above, this
5506      instrumentation code *can* be reordered freely: as long as a
5507      VM instruction is counted, the count increment can be placed
5508      anyehere.  Let GCC move this code and possibly achieve better
5509      throughput by exploiting instruction-level parallelism and
5510      therefore approximate more closely a non-profiled build. */
5511   JITTER_PROFILE_COUNT_UPDATE
5512      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5513       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5514 #endif
5515 
5516 /* User-specified code, instruction-beginning-c part: beginning. */
5517 
5518 
5519 /* User-specified code, instruction-beginning-c part: end */
5520 
5521 
5522     /* User code for branch-if-not-less/fR/fR . */
5523 
5524     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF1);
5525     jitterlisp_object undertop = JITTER_UNDER_TOP_MAINSTACK();
5526     jitterlisp_object top = JITTER_TOP_MAINSTACK();
5527     JITTER_NIP_MAINSTACK();
5528     JITTER_DROP_MAINSTACK();
5529     JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED(undertop, top, JITTER_ARGF0);
5530 
5531     /* End of the user code for branch-if-not-less/fR/fR . */
5532 
5533 /* User-specified code, instruction-end-c part: beginning. */
5534 
5535 
5536 /* User-specified code, instruction-end-c part: end */
5537 
5538     /* Undefine the branch-if-not-less/fR/fR argument macros so they can't be used
5539        by mistake in the instruction body coming next. */
5540 #   undef JITTER_SLOW_REGISTER_OFFSET0
5541 #   undef JITTER_ARG0
5542 #   undef JITTER_ARGN0
5543 #   undef JITTER_ARGU0
5544 #   undef JITTER_ARGP0
5545 #   undef JITTER_ARGF0
5546 #   undef JITTER_SLOW_REGISTER_OFFSET1
5547 #   undef JITTER_ARG1
5548 #   undef JITTER_ARGN1
5549 #   undef JITTER_ARGU1
5550 #   undef JITTER_ARGP1
5551 #   undef JITTER_ARGF1
5552 
5553 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5554 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5555 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5556 
5557   }
5558  JITTER_INSTRUCTION_EPILOG_(branch-if-not-less/fR/fR, branch_mif_mnot_mless__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5559 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5560 
5561   JITTER_INSTRUCTION_PROLOG_(branch-if-not-null/fR, branch_mif_mnot_mnull__fR, hot)
5562   {
5563     /* This specialized instruction is not a replacement. */
5564 #   undef JITTER_BRANCH_FAST
5565 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5566 #   undef JITTER_BRANCH_FAST_IF_ZERO
5567 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5568 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5569 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5570 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5571 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5572 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5573 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5574 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5575 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5576 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5577 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5578 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5579 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5580 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5581 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5582 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5583 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5584 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5585 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5586 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5587 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5588 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5589 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5590 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5591 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5592 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5593 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5594 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5595 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5596 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5597 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5598 #   undef JITTER_BRANCH_FAST_IF_AND
5599 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5600 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5601 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5602 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5603 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5604 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5605 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5606 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5607 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5608 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5609 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5610 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5611 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5612 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5613 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5614 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5615 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5616 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5617 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5618 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5619 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5620 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5621 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5622 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5623 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5624 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5625 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5626 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5627 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5628 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       22
5629 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-not-null/fR
5630 
5631 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mnot_mnull__fR
5632 
5633   /* The residual arity varies depending on whether we have fast labels. */
5634 #ifdef JITTER_HAVE_PATCH_IN
5635   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5636 #else
5637   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
5638 #endif // #ifdef JITTER_HAVE_PATCH_IN
5639 
5640   /* Define argument-access macros for branch-if-not-null/fR . */
5641 #ifdef JITTER_HAVE_PATCH_IN
5642   /* Define argument-access macros assuming that fast branches are enabled. */
5643     /* The 0th argument is a "residual" fast label.  Define its
5644        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5645        so that at replication time we know what instruction address to patch in. */
5646 #   define JITTER_ARGF0 0
5647     /* JITTER_ARG0 is intentionally not defined for a fast label. */
5648 
5649 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5650 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5651 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5652 
5653 #else
5654   /* Define argument-access macros assuming that fast branches are disabled. */
5655 #if defined(JITTER_DISPATCH_NO_THREADING)
5656 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
5657     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
5658 #elif defined (JITTER_REPLICATE)
5659 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
5660 #else
5661 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
5662 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5663 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5664 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5665 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5666 #   define JITTER_ARGF0 JITTER_ARGP0
5667 
5668 # endif // #ifdef JITTER_HAVE_PATCH_IN
5669 
5670 #if defined (JITTER_PROFILE_SAMPLE)
5671   JITTER_PROFILE_SAMPLE_UPDATE
5672      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5673       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5674   /* Force the compiler not move sample-profiling instrumentation
5675      beyond this point; this way the actual user code is timed.
5676      This is still not perfect, as residuals are materialised before
5677      we arrive here, but should be adequate at least for slow VM
5678      instructions. */
5679   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5680 #endif
5681 #if defined (JITTER_PROFILE_COUNT)
5682   /* Notice that, differently from the code above, this
5683      instrumentation code *can* be reordered freely: as long as a
5684      VM instruction is counted, the count increment can be placed
5685      anyehere.  Let GCC move this code and possibly achieve better
5686      throughput by exploiting instruction-level parallelism and
5687      therefore approximate more closely a non-profiled build. */
5688   JITTER_PROFILE_COUNT_UPDATE
5689      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5690       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5691 #endif
5692 
5693 /* User-specified code, instruction-beginning-c part: beginning. */
5694 
5695 
5696 /* User-specified code, instruction-beginning-c part: end */
5697 
5698 
5699     /* User code for branch-if-not-null/fR . */
5700 
5701     jitterlisp_object top = JITTER_TOP_MAINSTACK();
5702     JITTER_DROP_MAINSTACK();
5703     JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
5704 
5705     /* End of the user code for branch-if-not-null/fR . */
5706 
5707 /* User-specified code, instruction-end-c part: beginning. */
5708 
5709 
5710 /* User-specified code, instruction-end-c part: end */
5711 
5712     /* Undefine the branch-if-not-null/fR argument macros so they can't be used
5713        by mistake in the instruction body coming next. */
5714 #   undef JITTER_SLOW_REGISTER_OFFSET0
5715 #   undef JITTER_ARG0
5716 #   undef JITTER_ARGN0
5717 #   undef JITTER_ARGU0
5718 #   undef JITTER_ARGP0
5719 #   undef JITTER_ARGF0
5720 
5721 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5722 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5723 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5724 
5725   }
5726  JITTER_INSTRUCTION_EPILOG_(branch-if-not-null/fR, branch_mif_mnot_mnull__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5727 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5728 
5729   JITTER_INSTRUCTION_PROLOG_(branch-if-null/fR, branch_mif_mnull__fR, hot)
5730   {
5731     /* This specialized instruction is not a replacement. */
5732 #   undef JITTER_BRANCH_FAST
5733 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5734 #   undef JITTER_BRANCH_FAST_IF_ZERO
5735 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5736 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5737 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5738 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5739 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5740 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5741 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5742 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5743 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5744 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5745 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5746 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5747 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5748 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5749 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5750 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5751 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5752 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5753 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5754 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5755 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5756 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5757 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5758 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5759 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5760 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5761 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5762 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5763 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5764 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5765 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5766 #   undef JITTER_BRANCH_FAST_IF_AND
5767 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5768 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5769 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5770 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5771 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5772 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5773 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5774 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5775 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5776 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5777 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5778 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5779 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5780 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5781 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5782 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5783 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5784 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5785 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5786 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5787 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5788 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5789 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5790 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5791 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5792 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5793 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5794 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5795 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5796 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       23
5797 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-null/fR
5798 
5799 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mnull__fR
5800 
5801   /* The residual arity varies depending on whether we have fast labels. */
5802 #ifdef JITTER_HAVE_PATCH_IN
5803   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
5804 #else
5805   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
5806 #endif // #ifdef JITTER_HAVE_PATCH_IN
5807 
5808   /* Define argument-access macros for branch-if-null/fR . */
5809 #ifdef JITTER_HAVE_PATCH_IN
5810   /* Define argument-access macros assuming that fast branches are enabled. */
5811     /* The 0th argument is a "residual" fast label.  Define its
5812        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5813        so that at replication time we know what instruction address to patch in. */
5814 #   define JITTER_ARGF0 0
5815     /* JITTER_ARG0 is intentionally not defined for a fast label. */
5816 
5817 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5818 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5819 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5820 
5821 #else
5822   /* Define argument-access macros assuming that fast branches are disabled. */
5823 #if defined(JITTER_DISPATCH_NO_THREADING)
5824 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
5825     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
5826 #elif defined (JITTER_REPLICATE)
5827 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
5828 #else
5829 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
5830 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5831 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5832 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5833 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5834 #   define JITTER_ARGF0 JITTER_ARGP0
5835 
5836 # endif // #ifdef JITTER_HAVE_PATCH_IN
5837 
5838 #if defined (JITTER_PROFILE_SAMPLE)
5839   JITTER_PROFILE_SAMPLE_UPDATE
5840      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5841       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5842   /* Force the compiler not move sample-profiling instrumentation
5843      beyond this point; this way the actual user code is timed.
5844      This is still not perfect, as residuals are materialised before
5845      we arrive here, but should be adequate at least for slow VM
5846      instructions. */
5847   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
5848 #endif
5849 #if defined (JITTER_PROFILE_COUNT)
5850   /* Notice that, differently from the code above, this
5851      instrumentation code *can* be reordered freely: as long as a
5852      VM instruction is counted, the count increment can be placed
5853      anyehere.  Let GCC move this code and possibly achieve better
5854      throughput by exploiting instruction-level parallelism and
5855      therefore approximate more closely a non-profiled build. */
5856   JITTER_PROFILE_COUNT_UPDATE
5857      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
5858       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
5859 #endif
5860 
5861 /* User-specified code, instruction-beginning-c part: beginning. */
5862 
5863 
5864 /* User-specified code, instruction-beginning-c part: end */
5865 
5866 
5867     /* User code for branch-if-null/fR . */
5868 
5869     jitterlisp_object top = JITTER_TOP_MAINSTACK();
5870     JITTER_DROP_MAINSTACK();
5871     JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
5872 
5873     /* End of the user code for branch-if-null/fR . */
5874 
5875 /* User-specified code, instruction-end-c part: beginning. */
5876 
5877 
5878 /* User-specified code, instruction-end-c part: end */
5879 
5880     /* Undefine the branch-if-null/fR argument macros so they can't be used
5881        by mistake in the instruction body coming next. */
5882 #   undef JITTER_SLOW_REGISTER_OFFSET0
5883 #   undef JITTER_ARG0
5884 #   undef JITTER_ARGN0
5885 #   undef JITTER_ARGU0
5886 #   undef JITTER_ARGP0
5887 #   undef JITTER_ARGF0
5888 
5889 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
5890 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
5891 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
5892 
5893   }
5894  JITTER_INSTRUCTION_EPILOG_(branch-if-null/fR, branch_mif_mnull__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
5895 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
5896 
5897   JITTER_INSTRUCTION_PROLOG_(branch-if-register-non-zero/%rR/fR/fR, branch_mif_mregister_mnon_mzero___rrR__fR__fR, cold)
5898   {
5899     /* This specialized instruction is not a replacement. */
5900 #   undef JITTER_BRANCH_FAST
5901 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
5902 #   undef JITTER_BRANCH_FAST_IF_ZERO
5903 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
5904 #   undef JITTER_BRANCH_FAST_IF_NONZERO
5905 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
5906 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
5907 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
5908 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
5909 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
5910 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
5911 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
5912 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
5913 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
5914 #   undef JITTER_BRANCH_FAST_IF_EQUAL
5915 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
5916 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
5917 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
5918 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
5919 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
5920 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5921 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
5922 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5923 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
5924 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5925 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
5926 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5927 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
5928 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5929 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
5930 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5931 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
5932 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5933 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
5934 #   undef JITTER_BRANCH_FAST_IF_AND
5935 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
5936 #   undef JITTER_BRANCH_FAST_IF_NOTAND
5937 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
5938 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5939 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
5940 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5941 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
5942 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5943 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
5944 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5945 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
5946 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5947 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
5948 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5949 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
5950 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5951 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
5952 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5953 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
5954 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5955 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
5956 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5957 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
5958 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5959 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
5960 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5961 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
5962 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5963 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
5964 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       24
5965 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-register-non-zero/%rR/fR/fR
5966 
5967 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mregister_mnon_mzero___rrR__fR__fR
5968 
5969   /* The residual arity varies depending on whether we have fast labels. */
5970 #ifdef JITTER_HAVE_PATCH_IN
5971   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
5972 #else
5973   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
5974 #endif // #ifdef JITTER_HAVE_PATCH_IN
5975 
5976   /* Define argument-access macros for branch-if-register-non-zero/%rR/fR/fR . */
5977 #ifdef JITTER_HAVE_PATCH_IN
5978   /* Define argument-access macros assuming that fast branches are enabled. */
5979     /* The 0th argument is a slow (therefore residual, passed as an offset)
5980         register. */
5981   /* Define a macro expanding to the slow register offset. */
5982 #if defined(JITTER_DISPATCH_NO_THREADING)
5983 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
5984 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
5985 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
5986 #else
5987 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
5988 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
5989   /* Define a macro expanding to an l-value for the VM register content. */
5990 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
5991 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
5992 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
5993 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
5994 
5995     /* The 1th argument is a "residual" fast label.  Define its
5996        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
5997        so that at replication time we know what instruction address to patch in. */
5998 #   define JITTER_ARGF1 0
5999     /* JITTER_ARG1 is intentionally not defined for a fast label. */
6000 
6001 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
6002 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
6003 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
6004 
6005     /* The 2th argument is a "residual" fast label.  Define its
6006        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
6007        so that at replication time we know what instruction address to patch in. */
6008 #   define JITTER_ARGF2 1
6009     /* JITTER_ARG2 is intentionally not defined for a fast label. */
6010 
6011 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
6012 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
6013 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
6014 
6015 #else
6016   /* Define argument-access macros assuming that fast branches are disabled. */
6017     /* The 0th argument is a slow (therefore residual, passed as an offset)
6018         register. */
6019   /* Define a macro expanding to the slow register offset. */
6020 #if defined(JITTER_DISPATCH_NO_THREADING)
6021 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
6022 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
6023 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
6024 #else
6025 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
6026 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6027   /* Define a macro expanding to an l-value for the VM register content. */
6028 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
6029 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6030 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6031 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6032 #   define JITTER_ARGF0 JITTER_ARGP0
6033 
6034 #if defined(JITTER_DISPATCH_NO_THREADING)
6035 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
6036     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
6037 #elif defined (JITTER_REPLICATE)
6038 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
6039 #else
6040 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
6041 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6042 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
6043 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
6044 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
6045 #   define JITTER_ARGF1 JITTER_ARGP1
6046 
6047 #if defined(JITTER_DISPATCH_NO_THREADING)
6048 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
6049     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
6050 #elif defined (JITTER_REPLICATE)
6051 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
6052 #else
6053 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
6054 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6055 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
6056 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
6057 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
6058 #   define JITTER_ARGF2 JITTER_ARGP2
6059 
6060 # endif // #ifdef JITTER_HAVE_PATCH_IN
6061 
6062 #if defined (JITTER_PROFILE_SAMPLE)
6063   JITTER_PROFILE_SAMPLE_UPDATE
6064      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6065       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6066   /* Force the compiler not move sample-profiling instrumentation
6067      beyond this point; this way the actual user code is timed.
6068      This is still not perfect, as residuals are materialised before
6069      we arrive here, but should be adequate at least for slow VM
6070      instructions. */
6071   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6072 #endif
6073 #if defined (JITTER_PROFILE_COUNT)
6074   /* Notice that, differently from the code above, this
6075      instrumentation code *can* be reordered freely: as long as a
6076      VM instruction is counted, the count increment can be placed
6077      anyehere.  Let GCC move this code and possibly achieve better
6078      throughput by exploiting instruction-level parallelism and
6079      therefore approximate more closely a non-profiled build. */
6080   JITTER_PROFILE_COUNT_UPDATE
6081      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6082       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6083 #endif
6084 
6085 /* User-specified code, instruction-beginning-c part: beginning. */
6086 
6087 
6088 /* User-specified code, instruction-beginning-c part: end */
6089 
6090 
6091     /* User code for branch-if-register-non-zero/%rR/fR/fR . */
6092 
6093 #if ! defined (JITTERLISP_UNSAFE)
6094     JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
6095 #endif
6096     JITTER_BRANCH_FAST_IF_NOTEQUAL(JITTER_ARG0, JITTERLISP_FIXNUM_ENCODE(0),
6097                                    JITTER_ARGF1);
6098 
6099     /* End of the user code for branch-if-register-non-zero/%rR/fR/fR . */
6100 
6101 /* User-specified code, instruction-end-c part: beginning. */
6102 
6103 
6104 /* User-specified code, instruction-end-c part: end */
6105 
6106     /* Undefine the branch-if-register-non-zero/%rR/fR/fR argument macros so they can't be used
6107        by mistake in the instruction body coming next. */
6108 #   undef JITTER_SLOW_REGISTER_OFFSET0
6109 #   undef JITTER_ARG0
6110 #   undef JITTER_ARGN0
6111 #   undef JITTER_ARGU0
6112 #   undef JITTER_ARGP0
6113 #   undef JITTER_ARGF0
6114 #   undef JITTER_SLOW_REGISTER_OFFSET1
6115 #   undef JITTER_ARG1
6116 #   undef JITTER_ARGN1
6117 #   undef JITTER_ARGU1
6118 #   undef JITTER_ARGP1
6119 #   undef JITTER_ARGF1
6120 #   undef JITTER_SLOW_REGISTER_OFFSET2
6121 #   undef JITTER_ARG2
6122 #   undef JITTER_ARGN2
6123 #   undef JITTER_ARGU2
6124 #   undef JITTER_ARGP2
6125 #   undef JITTER_ARGF2
6126 
6127 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6128 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6129 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6130 
6131   }
6132  JITTER_INSTRUCTION_EPILOG_(branch-if-register-non-zero/%rR/fR/fR, branch_mif_mregister_mnon_mzero___rrR__fR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6133 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6134 
6135   JITTER_INSTRUCTION_PROLOG_(branch-if-true/fR, branch_mif_mtrue__fR, hot)
6136   {
6137     /* This specialized instruction is not a replacement. */
6138 #   undef JITTER_BRANCH_FAST
6139 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6140 #   undef JITTER_BRANCH_FAST_IF_ZERO
6141 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6142 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6143 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6144 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6145 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6146 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6147 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6148 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6149 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6150 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6151 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6152 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6153 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6154 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6155 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6156 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6157 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6158 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6159 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6160 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6161 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6162 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6163 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6164 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6165 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6166 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6167 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6168 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6169 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6170 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6171 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6172 #   undef JITTER_BRANCH_FAST_IF_AND
6173 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6174 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6175 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6176 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6177 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6178 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6179 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6180 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6181 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6182 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6183 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6184 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6185 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6186 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6187 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6188 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6189 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6190 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6191 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6192 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6193 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6194 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6195 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6196 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6197 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6198 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6199 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6200 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6201 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6202 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       25
6203 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         branch-if-true/fR
6204 
6205 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME branch_mif_mtrue__fR
6206 
6207   /* The residual arity varies depending on whether we have fast labels. */
6208 #ifdef JITTER_HAVE_PATCH_IN
6209   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
6210 #else
6211   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
6212 #endif // #ifdef JITTER_HAVE_PATCH_IN
6213 
6214   /* Define argument-access macros for branch-if-true/fR . */
6215 #ifdef JITTER_HAVE_PATCH_IN
6216   /* Define argument-access macros assuming that fast branches are enabled. */
6217     /* The 0th argument is a "residual" fast label.  Define its
6218        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
6219        so that at replication time we know what instruction address to patch in. */
6220 #   define JITTER_ARGF0 0
6221     /* JITTER_ARG0 is intentionally not defined for a fast label. */
6222 
6223 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6224 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6225 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6226 
6227 #else
6228   /* Define argument-access macros assuming that fast branches are disabled. */
6229 #if defined(JITTER_DISPATCH_NO_THREADING)
6230 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
6231     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
6232 #elif defined (JITTER_REPLICATE)
6233 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
6234 #else
6235 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
6236 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6237 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6238 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6239 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6240 #   define JITTER_ARGF0 JITTER_ARGP0
6241 
6242 # endif // #ifdef JITTER_HAVE_PATCH_IN
6243 
6244 #if defined (JITTER_PROFILE_SAMPLE)
6245   JITTER_PROFILE_SAMPLE_UPDATE
6246      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6247       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6248   /* Force the compiler not move sample-profiling instrumentation
6249      beyond this point; this way the actual user code is timed.
6250      This is still not perfect, as residuals are materialised before
6251      we arrive here, but should be adequate at least for slow VM
6252      instructions. */
6253   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6254 #endif
6255 #if defined (JITTER_PROFILE_COUNT)
6256   /* Notice that, differently from the code above, this
6257      instrumentation code *can* be reordered freely: as long as a
6258      VM instruction is counted, the count increment can be placed
6259      anyehere.  Let GCC move this code and possibly achieve better
6260      throughput by exploiting instruction-level parallelism and
6261      therefore approximate more closely a non-profiled build. */
6262   JITTER_PROFILE_COUNT_UPDATE
6263      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6264       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6265 #endif
6266 
6267 /* User-specified code, instruction-beginning-c part: beginning. */
6268 
6269 
6270 /* User-specified code, instruction-beginning-c part: end */
6271 
6272 
6273     /* User code for branch-if-true/fR . */
6274 
6275     jitterlisp_object top = JITTER_TOP_MAINSTACK();
6276     JITTER_DROP_MAINSTACK();
6277     JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
6278 
6279     /* End of the user code for branch-if-true/fR . */
6280 
6281 /* User-specified code, instruction-end-c part: beginning. */
6282 
6283 
6284 /* User-specified code, instruction-end-c part: end */
6285 
6286     /* Undefine the branch-if-true/fR argument macros so they can't be used
6287        by mistake in the instruction body coming next. */
6288 #   undef JITTER_SLOW_REGISTER_OFFSET0
6289 #   undef JITTER_ARG0
6290 #   undef JITTER_ARGN0
6291 #   undef JITTER_ARGU0
6292 #   undef JITTER_ARGP0
6293 #   undef JITTER_ARGF0
6294 
6295 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6296 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6297 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6298 
6299   }
6300  JITTER_INSTRUCTION_EPILOG_(branch-if-true/fR, branch_mif_mtrue__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6301 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6302 
6303   JITTER_INSTRUCTION_PROLOG_(call/n0/retR, call__n0__retR, hot)
6304   {
6305     /* This specialized instruction is not a replacement. */
6306 #   undef JITTER_BRANCH_FAST
6307 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6308 #   undef JITTER_BRANCH_FAST_IF_ZERO
6309 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6310 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6311 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6312 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6313 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6314 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6315 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6316 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6317 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6318 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6319 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6320 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6321 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6322 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6323 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6324 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6325 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6326 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6327 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6328 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6329 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6330 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6331 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6332 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6333 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6334 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6335 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6336 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6337 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6338 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6339 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6340 #   undef JITTER_BRANCH_FAST_IF_AND
6341 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6342 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6343 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6344 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6345 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6346 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6347 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6348 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6349 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6350 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6351 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6352 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6353 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6354 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6355 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6356 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6357 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6358 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6359 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6360 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6361 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6362 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6363 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6364 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6365 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6366 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6367 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6368 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6369 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6370     /* This specialized instruction is a caller.
6371        Its 1-th argument, a literal, is the return address where to jump
6372        back after the procedure returns.  Branch-and-link
6373        functionality is enabled for this instruction. */
6374 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
6375 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6376 
6377 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       26
6378 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n0/retR
6379 
6380 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n0__retR
6381 
6382   /* The residual arity for this instruction does not depend on fast labels. */
6383   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
6384 
6385     /* The 0th argument is a nonresidual literal. */
6386 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
6387 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6388 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6389 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6390 #   define JITTER_ARGF0 JITTER_ARGP0
6391 
6392     /* The 1th argument is a residual literal. */
6393 #if defined(JITTER_DISPATCH_NO_THREADING)
6394 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
6395     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
6396 #elif defined (JITTER_REPLICATE)
6397 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
6398 #else
6399 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
6400 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6401 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
6402 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
6403 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
6404 #   define JITTER_ARGF1 JITTER_ARGP1
6405 
6406 
6407 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
6408     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
6409   /* We use the implicit atgument at the end of the calling.
6410      instruction to discover the procedure return address. */
6411   const void * _jitter_return_pointer = JITTER_ARGP1;
6412   /* And make it accessible to the user (who will usually call
6413      JITTER_BRANCH_AND_LINK) thru a nice macro. */
6414 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
6415 #endif
6416 
6417 #if defined (JITTER_PROFILE_SAMPLE)
6418   JITTER_PROFILE_SAMPLE_UPDATE
6419      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6420       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6421   /* Force the compiler not move sample-profiling instrumentation
6422      beyond this point; this way the actual user code is timed.
6423      This is still not perfect, as residuals are materialised before
6424      we arrive here, but should be adequate at least for slow VM
6425      instructions. */
6426   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6427 #endif
6428 #if defined (JITTER_PROFILE_COUNT)
6429   /* Notice that, differently from the code above, this
6430      instrumentation code *can* be reordered freely: as long as a
6431      VM instruction is counted, the count increment can be placed
6432      anyehere.  Let GCC move this code and possibly achieve better
6433      throughput by exploiting instruction-level parallelism and
6434      therefore approximate more closely a non-profiled build. */
6435   JITTER_PROFILE_COUNT_UPDATE
6436      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6437       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6438 #endif
6439 
6440 /* User-specified code, instruction-beginning-c part: beginning. */
6441 
6442 
6443 /* User-specified code, instruction-beginning-c part: end */
6444 
6445 
6446     /* User code for call/n0/retR . */
6447 
6448     const jitter_uint in_arity = JITTER_ARGN0;
6449     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
6450     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
6451 
6452     if (c->kind == jitterlisp_closure_type_compiled)
6453       {
6454         /* Make place for the return address in the return stack.  The
6455            actual value will be written by the callee. */
6456         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
6457 
6458         /* Branch-and-link to the native code, whose first instruction
6459            will be a prolog. */
6460         struct jitterlisp_compiled_closure *cc = & c->compiled;
6461         JITTER_BRANCH_AND_LINK(cc->first_program_point);
6462       }
6463     else
6464       {
6465         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
6466 
6467         /* Push an element on the main stack.  This way we can ensure that
6468            every actual is accessible thru memory in a contiguous array,
6469            even if the main stack is TOS-optimized.  Compute the address
6470            (on the main stack backing) where the actuals begin.
6471 
6472            Notice that the interpreted function we are calling is allowed
6473            to call into compiled code in its turn.  This is not a problem,
6474            as we are not moving stack pointers down until the call ends:
6475            the unused part of the main and return stacks is available to
6476            the callee. */
6477         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
6478         jitterlisp_object *actuals
6479           // FIXME: add a stack operator to compute this address.
6480           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
6481 
6482         /* Call the interpreter. */
6483         jitterlisp_object interpretation_result
6484           = jitterlisp_call_interpreted (ic, actuals, in_arity);
6485 
6486         /* Remove as many elements as the in-arity plus one (the callee) from
6487            the stack, without affecting the top.  Unless JITTER_ARGN0 is
6488            residual this whole loops compiles to one instruction when the main
6489            stack is TOS-optimized, and doesn't touch memory. */
6490         int i;
6491         for (i = 0; i < in_arity + 1; i ++)
6492           JITTER_NIP_MAINSTACK();
6493 
6494         /* Now the stack is one element higher than it was before the call,
6495            containing the unspecified element at the top.  Replace it with
6496            the result.  Again this doesn't touch memory. */
6497         JITTER_TOP_MAINSTACK() = interpretation_result;
6498       }
6499 
6500     /* End of the user code for call/n0/retR . */
6501 
6502 /* User-specified code, instruction-end-c part: beginning. */
6503 
6504 
6505 /* User-specified code, instruction-end-c part: end */
6506 
6507     /* Undefine macros only visible in caller instructions. */
6508 #   undef JITTER_BRANCH_AND_LINK
6509 #   undef JITTER_BRANCH_FAST_AND_LINK
6510 
6511     /* Undefine the call/n0/retR argument macros so they can't be used
6512        by mistake in the instruction body coming next. */
6513 #   undef JITTER_SLOW_REGISTER_OFFSET0
6514 #   undef JITTER_ARG0
6515 #   undef JITTER_ARGN0
6516 #   undef JITTER_ARGU0
6517 #   undef JITTER_ARGP0
6518 #   undef JITTER_ARGF0
6519 #   undef JITTER_SLOW_REGISTER_OFFSET1
6520 #   undef JITTER_ARG1
6521 #   undef JITTER_ARGN1
6522 #   undef JITTER_ARGU1
6523 #   undef JITTER_ARGP1
6524 #   undef JITTER_ARGF1
6525 
6526 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6527 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6528 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6529 
6530   }
6531 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
6532     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
6533 # undef JITTER_RETURN_ADDRESS
6534 #endif
6535 
6536  JITTER_INSTRUCTION_EPILOG_(call/n0/retR, call__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6537 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6538 
6539   JITTER_INSTRUCTION_PROLOG_(call/n1/retR, call__n1__retR, hot)
6540   {
6541     /* This specialized instruction is not a replacement. */
6542 #   undef JITTER_BRANCH_FAST
6543 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6544 #   undef JITTER_BRANCH_FAST_IF_ZERO
6545 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6546 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6547 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6548 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6549 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6550 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6551 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6552 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6553 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6554 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6555 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6556 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6557 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6558 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6559 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6560 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6561 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6562 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6563 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6564 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6565 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6566 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6567 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6568 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6569 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6570 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6571 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6572 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6573 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6574 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6575 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6576 #   undef JITTER_BRANCH_FAST_IF_AND
6577 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6578 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6579 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6580 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6581 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6582 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6583 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6584 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6585 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6586 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6587 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6588 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6589 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6590 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6591 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6592 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6593 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6594 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6595 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6596 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6597 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6598 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6599 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6600 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6601 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6602 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6603 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6604 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6605 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6606     /* This specialized instruction is a caller.
6607        Its 1-th argument, a literal, is the return address where to jump
6608        back after the procedure returns.  Branch-and-link
6609        functionality is enabled for this instruction. */
6610 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
6611 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6612 
6613 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       27
6614 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n1/retR
6615 
6616 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n1__retR
6617 
6618   /* The residual arity for this instruction does not depend on fast labels. */
6619   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
6620 
6621     /* The 0th argument is a nonresidual literal. */
6622 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
6623 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6624 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6625 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6626 #   define JITTER_ARGF0 JITTER_ARGP0
6627 
6628     /* The 1th argument is a residual literal. */
6629 #if defined(JITTER_DISPATCH_NO_THREADING)
6630 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
6631     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
6632 #elif defined (JITTER_REPLICATE)
6633 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
6634 #else
6635 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
6636 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6637 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
6638 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
6639 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
6640 #   define JITTER_ARGF1 JITTER_ARGP1
6641 
6642 
6643 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
6644     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
6645   /* We use the implicit atgument at the end of the calling.
6646      instruction to discover the procedure return address. */
6647   const void * _jitter_return_pointer = JITTER_ARGP1;
6648   /* And make it accessible to the user (who will usually call
6649      JITTER_BRANCH_AND_LINK) thru a nice macro. */
6650 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
6651 #endif
6652 
6653 #if defined (JITTER_PROFILE_SAMPLE)
6654   JITTER_PROFILE_SAMPLE_UPDATE
6655      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6656       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6657   /* Force the compiler not move sample-profiling instrumentation
6658      beyond this point; this way the actual user code is timed.
6659      This is still not perfect, as residuals are materialised before
6660      we arrive here, but should be adequate at least for slow VM
6661      instructions. */
6662   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6663 #endif
6664 #if defined (JITTER_PROFILE_COUNT)
6665   /* Notice that, differently from the code above, this
6666      instrumentation code *can* be reordered freely: as long as a
6667      VM instruction is counted, the count increment can be placed
6668      anyehere.  Let GCC move this code and possibly achieve better
6669      throughput by exploiting instruction-level parallelism and
6670      therefore approximate more closely a non-profiled build. */
6671   JITTER_PROFILE_COUNT_UPDATE
6672      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6673       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6674 #endif
6675 
6676 /* User-specified code, instruction-beginning-c part: beginning. */
6677 
6678 
6679 /* User-specified code, instruction-beginning-c part: end */
6680 
6681 
6682     /* User code for call/n1/retR . */
6683 
6684     const jitter_uint in_arity = JITTER_ARGN0;
6685     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
6686     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
6687 
6688     if (c->kind == jitterlisp_closure_type_compiled)
6689       {
6690         /* Make place for the return address in the return stack.  The
6691            actual value will be written by the callee. */
6692         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
6693 
6694         /* Branch-and-link to the native code, whose first instruction
6695            will be a prolog. */
6696         struct jitterlisp_compiled_closure *cc = & c->compiled;
6697         JITTER_BRANCH_AND_LINK(cc->first_program_point);
6698       }
6699     else
6700       {
6701         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
6702 
6703         /* Push an element on the main stack.  This way we can ensure that
6704            every actual is accessible thru memory in a contiguous array,
6705            even if the main stack is TOS-optimized.  Compute the address
6706            (on the main stack backing) where the actuals begin.
6707 
6708            Notice that the interpreted function we are calling is allowed
6709            to call into compiled code in its turn.  This is not a problem,
6710            as we are not moving stack pointers down until the call ends:
6711            the unused part of the main and return stacks is available to
6712            the callee. */
6713         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
6714         jitterlisp_object *actuals
6715           // FIXME: add a stack operator to compute this address.
6716           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
6717 
6718         /* Call the interpreter. */
6719         jitterlisp_object interpretation_result
6720           = jitterlisp_call_interpreted (ic, actuals, in_arity);
6721 
6722         /* Remove as many elements as the in-arity plus one (the callee) from
6723            the stack, without affecting the top.  Unless JITTER_ARGN0 is
6724            residual this whole loops compiles to one instruction when the main
6725            stack is TOS-optimized, and doesn't touch memory. */
6726         int i;
6727         for (i = 0; i < in_arity + 1; i ++)
6728           JITTER_NIP_MAINSTACK();
6729 
6730         /* Now the stack is one element higher than it was before the call,
6731            containing the unspecified element at the top.  Replace it with
6732            the result.  Again this doesn't touch memory. */
6733         JITTER_TOP_MAINSTACK() = interpretation_result;
6734       }
6735 
6736     /* End of the user code for call/n1/retR . */
6737 
6738 /* User-specified code, instruction-end-c part: beginning. */
6739 
6740 
6741 /* User-specified code, instruction-end-c part: end */
6742 
6743     /* Undefine macros only visible in caller instructions. */
6744 #   undef JITTER_BRANCH_AND_LINK
6745 #   undef JITTER_BRANCH_FAST_AND_LINK
6746 
6747     /* Undefine the call/n1/retR argument macros so they can't be used
6748        by mistake in the instruction body coming next. */
6749 #   undef JITTER_SLOW_REGISTER_OFFSET0
6750 #   undef JITTER_ARG0
6751 #   undef JITTER_ARGN0
6752 #   undef JITTER_ARGU0
6753 #   undef JITTER_ARGP0
6754 #   undef JITTER_ARGF0
6755 #   undef JITTER_SLOW_REGISTER_OFFSET1
6756 #   undef JITTER_ARG1
6757 #   undef JITTER_ARGN1
6758 #   undef JITTER_ARGU1
6759 #   undef JITTER_ARGP1
6760 #   undef JITTER_ARGF1
6761 
6762 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6763 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
6764 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
6765 
6766   }
6767 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
6768     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
6769 # undef JITTER_RETURN_ADDRESS
6770 #endif
6771 
6772  JITTER_INSTRUCTION_EPILOG_(call/n1/retR, call__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
6773 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
6774 
6775   JITTER_INSTRUCTION_PROLOG_(call/n2/retR, call__n2__retR, hot)
6776   {
6777     /* This specialized instruction is not a replacement. */
6778 #   undef JITTER_BRANCH_FAST
6779 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
6780 #   undef JITTER_BRANCH_FAST_IF_ZERO
6781 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
6782 #   undef JITTER_BRANCH_FAST_IF_NONZERO
6783 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
6784 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
6785 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
6786 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
6787 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
6788 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
6789 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
6790 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
6791 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
6792 #   undef JITTER_BRANCH_FAST_IF_EQUAL
6793 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
6794 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
6795 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
6796 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
6797 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
6798 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6799 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
6800 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6801 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
6802 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6803 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
6804 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6805 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
6806 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6807 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
6808 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6809 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
6810 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6811 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
6812 #   undef JITTER_BRANCH_FAST_IF_AND
6813 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
6814 #   undef JITTER_BRANCH_FAST_IF_NOTAND
6815 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
6816 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6817 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
6818 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6819 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
6820 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6821 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
6822 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6823 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
6824 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6825 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
6826 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6827 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
6828 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6829 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6830 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6831 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
6832 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6833 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
6834 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6835 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
6836 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6837 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
6838 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6839 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
6840 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6841 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
6842     /* This specialized instruction is a caller.
6843        Its 1-th argument, a literal, is the return address where to jump
6844        back after the procedure returns.  Branch-and-link
6845        functionality is enabled for this instruction. */
6846 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
6847 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
6848 
6849 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       28
6850 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n2/retR
6851 
6852 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n2__retR
6853 
6854   /* The residual arity for this instruction does not depend on fast labels. */
6855   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
6856 
6857     /* The 0th argument is a nonresidual literal. */
6858 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
6859 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
6860 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
6861 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
6862 #   define JITTER_ARGF0 JITTER_ARGP0
6863 
6864     /* The 1th argument is a residual literal. */
6865 #if defined(JITTER_DISPATCH_NO_THREADING)
6866 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
6867     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
6868 #elif defined (JITTER_REPLICATE)
6869 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
6870 #else
6871 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
6872 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
6873 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
6874 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
6875 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
6876 #   define JITTER_ARGF1 JITTER_ARGP1
6877 
6878 
6879 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
6880     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
6881   /* We use the implicit atgument at the end of the calling.
6882      instruction to discover the procedure return address. */
6883   const void * _jitter_return_pointer = JITTER_ARGP1;
6884   /* And make it accessible to the user (who will usually call
6885      JITTER_BRANCH_AND_LINK) thru a nice macro. */
6886 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
6887 #endif
6888 
6889 #if defined (JITTER_PROFILE_SAMPLE)
6890   JITTER_PROFILE_SAMPLE_UPDATE
6891      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6892       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6893   /* Force the compiler not move sample-profiling instrumentation
6894      beyond this point; this way the actual user code is timed.
6895      This is still not perfect, as residuals are materialised before
6896      we arrive here, but should be adequate at least for slow VM
6897      instructions. */
6898   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
6899 #endif
6900 #if defined (JITTER_PROFILE_COUNT)
6901   /* Notice that, differently from the code above, this
6902      instrumentation code *can* be reordered freely: as long as a
6903      VM instruction is counted, the count increment can be placed
6904      anyehere.  Let GCC move this code and possibly achieve better
6905      throughput by exploiting instruction-level parallelism and
6906      therefore approximate more closely a non-profiled build. */
6907   JITTER_PROFILE_COUNT_UPDATE
6908      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
6909       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
6910 #endif
6911 
6912 /* User-specified code, instruction-beginning-c part: beginning. */
6913 
6914 
6915 /* User-specified code, instruction-beginning-c part: end */
6916 
6917 
6918     /* User code for call/n2/retR . */
6919 
6920     const jitter_uint in_arity = JITTER_ARGN0;
6921     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
6922     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
6923 
6924     if (c->kind == jitterlisp_closure_type_compiled)
6925       {
6926         /* Make place for the return address in the return stack.  The
6927            actual value will be written by the callee. */
6928         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
6929 
6930         /* Branch-and-link to the native code, whose first instruction
6931            will be a prolog. */
6932         struct jitterlisp_compiled_closure *cc = & c->compiled;
6933         JITTER_BRANCH_AND_LINK(cc->first_program_point);
6934       }
6935     else
6936       {
6937         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
6938 
6939         /* Push an element on the main stack.  This way we can ensure that
6940            every actual is accessible thru memory in a contiguous array,
6941            even if the main stack is TOS-optimized.  Compute the address
6942            (on the main stack backing) where the actuals begin.
6943 
6944            Notice that the interpreted function we are calling is allowed
6945            to call into compiled code in its turn.  This is not a problem,
6946            as we are not moving stack pointers down until the call ends:
6947            the unused part of the main and return stacks is available to
6948            the callee. */
6949         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
6950         jitterlisp_object *actuals
6951           // FIXME: add a stack operator to compute this address.
6952           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
6953 
6954         /* Call the interpreter. */
6955         jitterlisp_object interpretation_result
6956           = jitterlisp_call_interpreted (ic, actuals, in_arity);
6957 
6958         /* Remove as many elements as the in-arity plus one (the callee) from
6959            the stack, without affecting the top.  Unless JITTER_ARGN0 is
6960            residual this whole loops compiles to one instruction when the main
6961            stack is TOS-optimized, and doesn't touch memory. */
6962         int i;
6963         for (i = 0; i < in_arity + 1; i ++)
6964           JITTER_NIP_MAINSTACK();
6965 
6966         /* Now the stack is one element higher than it was before the call,
6967            containing the unspecified element at the top.  Replace it with
6968            the result.  Again this doesn't touch memory. */
6969         JITTER_TOP_MAINSTACK() = interpretation_result;
6970       }
6971 
6972     /* End of the user code for call/n2/retR . */
6973 
6974 /* User-specified code, instruction-end-c part: beginning. */
6975 
6976 
6977 /* User-specified code, instruction-end-c part: end */
6978 
6979     /* Undefine macros only visible in caller instructions. */
6980 #   undef JITTER_BRANCH_AND_LINK
6981 #   undef JITTER_BRANCH_FAST_AND_LINK
6982 
6983     /* Undefine the call/n2/retR argument macros so they can't be used
6984        by mistake in the instruction body coming next. */
6985 #   undef JITTER_SLOW_REGISTER_OFFSET0
6986 #   undef JITTER_ARG0
6987 #   undef JITTER_ARGN0
6988 #   undef JITTER_ARGU0
6989 #   undef JITTER_ARGP0
6990 #   undef JITTER_ARGF0
6991 #   undef JITTER_SLOW_REGISTER_OFFSET1
6992 #   undef JITTER_ARG1
6993 #   undef JITTER_ARGN1
6994 #   undef JITTER_ARGU1
6995 #   undef JITTER_ARGP1
6996 #   undef JITTER_ARGF1
6997 
6998 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
6999 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7000 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7001 
7002   }
7003 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7004     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7005 # undef JITTER_RETURN_ADDRESS
7006 #endif
7007 
7008  JITTER_INSTRUCTION_EPILOG_(call/n2/retR, call__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7009 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7010 
7011   JITTER_INSTRUCTION_PROLOG_(call/n3/retR, call__n3__retR, hot)
7012   {
7013     /* This specialized instruction is not a replacement. */
7014 #   undef JITTER_BRANCH_FAST
7015 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7016 #   undef JITTER_BRANCH_FAST_IF_ZERO
7017 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7018 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7019 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7020 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7021 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7022 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7023 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7024 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7025 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7026 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7027 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7028 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7029 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7030 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7031 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7032 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7033 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7034 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7035 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7036 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7037 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7038 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7039 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7040 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7041 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7042 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7043 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7044 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7045 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7046 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7047 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7048 #   undef JITTER_BRANCH_FAST_IF_AND
7049 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7050 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7051 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7052 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7053 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7054 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7055 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7056 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7057 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7058 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7059 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7060 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7061 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7062 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7063 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7064 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7065 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7066 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7067 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7068 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7069 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7070 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7071 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7072 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7073 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7074 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7075 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7076 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7077 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7078     /* This specialized instruction is a caller.
7079        Its 1-th argument, a literal, is the return address where to jump
7080        back after the procedure returns.  Branch-and-link
7081        functionality is enabled for this instruction. */
7082 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
7083 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7084 
7085 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       29
7086 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n3/retR
7087 
7088 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n3__retR
7089 
7090   /* The residual arity for this instruction does not depend on fast labels. */
7091   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
7092 
7093     /* The 0th argument is a nonresidual literal. */
7094 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
7095 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7096 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7097 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7098 #   define JITTER_ARGF0 JITTER_ARGP0
7099 
7100     /* The 1th argument is a residual literal. */
7101 #if defined(JITTER_DISPATCH_NO_THREADING)
7102 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
7103     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
7104 #elif defined (JITTER_REPLICATE)
7105 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
7106 #else
7107 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
7108 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
7109 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
7110 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
7111 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
7112 #   define JITTER_ARGF1 JITTER_ARGP1
7113 
7114 
7115 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7116     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7117   /* We use the implicit atgument at the end of the calling.
7118      instruction to discover the procedure return address. */
7119   const void * _jitter_return_pointer = JITTER_ARGP1;
7120   /* And make it accessible to the user (who will usually call
7121      JITTER_BRANCH_AND_LINK) thru a nice macro. */
7122 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
7123 #endif
7124 
7125 #if defined (JITTER_PROFILE_SAMPLE)
7126   JITTER_PROFILE_SAMPLE_UPDATE
7127      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7128       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7129   /* Force the compiler not move sample-profiling instrumentation
7130      beyond this point; this way the actual user code is timed.
7131      This is still not perfect, as residuals are materialised before
7132      we arrive here, but should be adequate at least for slow VM
7133      instructions. */
7134   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7135 #endif
7136 #if defined (JITTER_PROFILE_COUNT)
7137   /* Notice that, differently from the code above, this
7138      instrumentation code *can* be reordered freely: as long as a
7139      VM instruction is counted, the count increment can be placed
7140      anyehere.  Let GCC move this code and possibly achieve better
7141      throughput by exploiting instruction-level parallelism and
7142      therefore approximate more closely a non-profiled build. */
7143   JITTER_PROFILE_COUNT_UPDATE
7144      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7145       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7146 #endif
7147 
7148 /* User-specified code, instruction-beginning-c part: beginning. */
7149 
7150 
7151 /* User-specified code, instruction-beginning-c part: end */
7152 
7153 
7154     /* User code for call/n3/retR . */
7155 
7156     const jitter_uint in_arity = JITTER_ARGN0;
7157     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
7158     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
7159 
7160     if (c->kind == jitterlisp_closure_type_compiled)
7161       {
7162         /* Make place for the return address in the return stack.  The
7163            actual value will be written by the callee. */
7164         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
7165 
7166         /* Branch-and-link to the native code, whose first instruction
7167            will be a prolog. */
7168         struct jitterlisp_compiled_closure *cc = & c->compiled;
7169         JITTER_BRANCH_AND_LINK(cc->first_program_point);
7170       }
7171     else
7172       {
7173         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
7174 
7175         /* Push an element on the main stack.  This way we can ensure that
7176            every actual is accessible thru memory in a contiguous array,
7177            even if the main stack is TOS-optimized.  Compute the address
7178            (on the main stack backing) where the actuals begin.
7179 
7180            Notice that the interpreted function we are calling is allowed
7181            to call into compiled code in its turn.  This is not a problem,
7182            as we are not moving stack pointers down until the call ends:
7183            the unused part of the main and return stacks is available to
7184            the callee. */
7185         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
7186         jitterlisp_object *actuals
7187           // FIXME: add a stack operator to compute this address.
7188           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
7189 
7190         /* Call the interpreter. */
7191         jitterlisp_object interpretation_result
7192           = jitterlisp_call_interpreted (ic, actuals, in_arity);
7193 
7194         /* Remove as many elements as the in-arity plus one (the callee) from
7195            the stack, without affecting the top.  Unless JITTER_ARGN0 is
7196            residual this whole loops compiles to one instruction when the main
7197            stack is TOS-optimized, and doesn't touch memory. */
7198         int i;
7199         for (i = 0; i < in_arity + 1; i ++)
7200           JITTER_NIP_MAINSTACK();
7201 
7202         /* Now the stack is one element higher than it was before the call,
7203            containing the unspecified element at the top.  Replace it with
7204            the result.  Again this doesn't touch memory. */
7205         JITTER_TOP_MAINSTACK() = interpretation_result;
7206       }
7207 
7208     /* End of the user code for call/n3/retR . */
7209 
7210 /* User-specified code, instruction-end-c part: beginning. */
7211 
7212 
7213 /* User-specified code, instruction-end-c part: end */
7214 
7215     /* Undefine macros only visible in caller instructions. */
7216 #   undef JITTER_BRANCH_AND_LINK
7217 #   undef JITTER_BRANCH_FAST_AND_LINK
7218 
7219     /* Undefine the call/n3/retR argument macros so they can't be used
7220        by mistake in the instruction body coming next. */
7221 #   undef JITTER_SLOW_REGISTER_OFFSET0
7222 #   undef JITTER_ARG0
7223 #   undef JITTER_ARGN0
7224 #   undef JITTER_ARGU0
7225 #   undef JITTER_ARGP0
7226 #   undef JITTER_ARGF0
7227 #   undef JITTER_SLOW_REGISTER_OFFSET1
7228 #   undef JITTER_ARG1
7229 #   undef JITTER_ARGN1
7230 #   undef JITTER_ARGU1
7231 #   undef JITTER_ARGP1
7232 #   undef JITTER_ARGF1
7233 
7234 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7235 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7236 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7237 
7238   }
7239 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7240     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7241 # undef JITTER_RETURN_ADDRESS
7242 #endif
7243 
7244  JITTER_INSTRUCTION_EPILOG_(call/n3/retR, call__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7245 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7246 
7247   JITTER_INSTRUCTION_PROLOG_(call/n4/retR, call__n4__retR, hot)
7248   {
7249     /* This specialized instruction is not a replacement. */
7250 #   undef JITTER_BRANCH_FAST
7251 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7252 #   undef JITTER_BRANCH_FAST_IF_ZERO
7253 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7254 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7255 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7256 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7257 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7258 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7259 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7260 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7261 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7262 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7263 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7264 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7265 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7266 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7267 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7268 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7269 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7270 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7271 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7272 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7273 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7274 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7275 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7276 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7277 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7278 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7279 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7280 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7281 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7282 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7283 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7284 #   undef JITTER_BRANCH_FAST_IF_AND
7285 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7286 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7287 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7288 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7289 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7290 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7291 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7292 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7293 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7294 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7295 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7296 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7297 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7298 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7299 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7300 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7301 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7302 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7303 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7304 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7305 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7306 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7307 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7308 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7309 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7310 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7311 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7312 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7313 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7314     /* This specialized instruction is a caller.
7315        Its 1-th argument, a literal, is the return address where to jump
7316        back after the procedure returns.  Branch-and-link
7317        functionality is enabled for this instruction. */
7318 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
7319 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7320 
7321 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       30
7322 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n4/retR
7323 
7324 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n4__retR
7325 
7326   /* The residual arity for this instruction does not depend on fast labels. */
7327   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
7328 
7329     /* The 0th argument is a nonresidual literal. */
7330 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
7331 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7332 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7333 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7334 #   define JITTER_ARGF0 JITTER_ARGP0
7335 
7336     /* The 1th argument is a residual literal. */
7337 #if defined(JITTER_DISPATCH_NO_THREADING)
7338 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
7339     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
7340 #elif defined (JITTER_REPLICATE)
7341 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
7342 #else
7343 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
7344 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
7345 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
7346 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
7347 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
7348 #   define JITTER_ARGF1 JITTER_ARGP1
7349 
7350 
7351 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7352     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7353   /* We use the implicit atgument at the end of the calling.
7354      instruction to discover the procedure return address. */
7355   const void * _jitter_return_pointer = JITTER_ARGP1;
7356   /* And make it accessible to the user (who will usually call
7357      JITTER_BRANCH_AND_LINK) thru a nice macro. */
7358 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
7359 #endif
7360 
7361 #if defined (JITTER_PROFILE_SAMPLE)
7362   JITTER_PROFILE_SAMPLE_UPDATE
7363      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7364       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7365   /* Force the compiler not move sample-profiling instrumentation
7366      beyond this point; this way the actual user code is timed.
7367      This is still not perfect, as residuals are materialised before
7368      we arrive here, but should be adequate at least for slow VM
7369      instructions. */
7370   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7371 #endif
7372 #if defined (JITTER_PROFILE_COUNT)
7373   /* Notice that, differently from the code above, this
7374      instrumentation code *can* be reordered freely: as long as a
7375      VM instruction is counted, the count increment can be placed
7376      anyehere.  Let GCC move this code and possibly achieve better
7377      throughput by exploiting instruction-level parallelism and
7378      therefore approximate more closely a non-profiled build. */
7379   JITTER_PROFILE_COUNT_UPDATE
7380      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7381       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7382 #endif
7383 
7384 /* User-specified code, instruction-beginning-c part: beginning. */
7385 
7386 
7387 /* User-specified code, instruction-beginning-c part: end */
7388 
7389 
7390     /* User code for call/n4/retR . */
7391 
7392     const jitter_uint in_arity = JITTER_ARGN0;
7393     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
7394     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
7395 
7396     if (c->kind == jitterlisp_closure_type_compiled)
7397       {
7398         /* Make place for the return address in the return stack.  The
7399            actual value will be written by the callee. */
7400         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
7401 
7402         /* Branch-and-link to the native code, whose first instruction
7403            will be a prolog. */
7404         struct jitterlisp_compiled_closure *cc = & c->compiled;
7405         JITTER_BRANCH_AND_LINK(cc->first_program_point);
7406       }
7407     else
7408       {
7409         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
7410 
7411         /* Push an element on the main stack.  This way we can ensure that
7412            every actual is accessible thru memory in a contiguous array,
7413            even if the main stack is TOS-optimized.  Compute the address
7414            (on the main stack backing) where the actuals begin.
7415 
7416            Notice that the interpreted function we are calling is allowed
7417            to call into compiled code in its turn.  This is not a problem,
7418            as we are not moving stack pointers down until the call ends:
7419            the unused part of the main and return stacks is available to
7420            the callee. */
7421         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
7422         jitterlisp_object *actuals
7423           // FIXME: add a stack operator to compute this address.
7424           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
7425 
7426         /* Call the interpreter. */
7427         jitterlisp_object interpretation_result
7428           = jitterlisp_call_interpreted (ic, actuals, in_arity);
7429 
7430         /* Remove as many elements as the in-arity plus one (the callee) from
7431            the stack, without affecting the top.  Unless JITTER_ARGN0 is
7432            residual this whole loops compiles to one instruction when the main
7433            stack is TOS-optimized, and doesn't touch memory. */
7434         int i;
7435         for (i = 0; i < in_arity + 1; i ++)
7436           JITTER_NIP_MAINSTACK();
7437 
7438         /* Now the stack is one element higher than it was before the call,
7439            containing the unspecified element at the top.  Replace it with
7440            the result.  Again this doesn't touch memory. */
7441         JITTER_TOP_MAINSTACK() = interpretation_result;
7442       }
7443 
7444     /* End of the user code for call/n4/retR . */
7445 
7446 /* User-specified code, instruction-end-c part: beginning. */
7447 
7448 
7449 /* User-specified code, instruction-end-c part: end */
7450 
7451     /* Undefine macros only visible in caller instructions. */
7452 #   undef JITTER_BRANCH_AND_LINK
7453 #   undef JITTER_BRANCH_FAST_AND_LINK
7454 
7455     /* Undefine the call/n4/retR argument macros so they can't be used
7456        by mistake in the instruction body coming next. */
7457 #   undef JITTER_SLOW_REGISTER_OFFSET0
7458 #   undef JITTER_ARG0
7459 #   undef JITTER_ARGN0
7460 #   undef JITTER_ARGU0
7461 #   undef JITTER_ARGP0
7462 #   undef JITTER_ARGF0
7463 #   undef JITTER_SLOW_REGISTER_OFFSET1
7464 #   undef JITTER_ARG1
7465 #   undef JITTER_ARGN1
7466 #   undef JITTER_ARGU1
7467 #   undef JITTER_ARGP1
7468 #   undef JITTER_ARGF1
7469 
7470 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7471 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7472 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7473 
7474   }
7475 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7476     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7477 # undef JITTER_RETURN_ADDRESS
7478 #endif
7479 
7480  JITTER_INSTRUCTION_EPILOG_(call/n4/retR, call__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7481 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7482 
7483   JITTER_INSTRUCTION_PROLOG_(call/n5/retR, call__n5__retR, hot)
7484   {
7485     /* This specialized instruction is not a replacement. */
7486 #   undef JITTER_BRANCH_FAST
7487 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7488 #   undef JITTER_BRANCH_FAST_IF_ZERO
7489 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7490 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7491 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7492 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7493 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7494 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7495 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7496 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7497 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7498 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7499 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7500 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7501 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7502 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7503 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7504 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7505 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7506 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7507 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7508 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7509 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7510 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7511 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7512 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7513 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7514 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7515 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7516 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7517 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7518 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7519 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7520 #   undef JITTER_BRANCH_FAST_IF_AND
7521 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7522 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7523 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7524 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7525 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7526 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7527 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7528 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7529 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7530 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7531 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7532 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7533 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7534 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7535 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7536 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7537 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7538 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7539 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7540 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7541 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7542 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7543 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7544 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7545 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7546 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7547 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7548 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7549 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7550     /* This specialized instruction is a caller.
7551        Its 1-th argument, a literal, is the return address where to jump
7552        back after the procedure returns.  Branch-and-link
7553        functionality is enabled for this instruction. */
7554 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
7555 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7556 
7557 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       31
7558 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n5/retR
7559 
7560 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n5__retR
7561 
7562   /* The residual arity for this instruction does not depend on fast labels. */
7563   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
7564 
7565     /* The 0th argument is a nonresidual literal. */
7566 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
7567 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7568 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7569 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7570 #   define JITTER_ARGF0 JITTER_ARGP0
7571 
7572     /* The 1th argument is a residual literal. */
7573 #if defined(JITTER_DISPATCH_NO_THREADING)
7574 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
7575     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
7576 #elif defined (JITTER_REPLICATE)
7577 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
7578 #else
7579 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
7580 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
7581 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
7582 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
7583 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
7584 #   define JITTER_ARGF1 JITTER_ARGP1
7585 
7586 
7587 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7588     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7589   /* We use the implicit atgument at the end of the calling.
7590      instruction to discover the procedure return address. */
7591   const void * _jitter_return_pointer = JITTER_ARGP1;
7592   /* And make it accessible to the user (who will usually call
7593      JITTER_BRANCH_AND_LINK) thru a nice macro. */
7594 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
7595 #endif
7596 
7597 #if defined (JITTER_PROFILE_SAMPLE)
7598   JITTER_PROFILE_SAMPLE_UPDATE
7599      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7600       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7601   /* Force the compiler not move sample-profiling instrumentation
7602      beyond this point; this way the actual user code is timed.
7603      This is still not perfect, as residuals are materialised before
7604      we arrive here, but should be adequate at least for slow VM
7605      instructions. */
7606   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
7607 #endif
7608 #if defined (JITTER_PROFILE_COUNT)
7609   /* Notice that, differently from the code above, this
7610      instrumentation code *can* be reordered freely: as long as a
7611      VM instruction is counted, the count increment can be placed
7612      anyehere.  Let GCC move this code and possibly achieve better
7613      throughput by exploiting instruction-level parallelism and
7614      therefore approximate more closely a non-profiled build. */
7615   JITTER_PROFILE_COUNT_UPDATE
7616      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7617       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7618 #endif
7619 
7620 /* User-specified code, instruction-beginning-c part: beginning. */
7621 
7622 
7623 /* User-specified code, instruction-beginning-c part: end */
7624 
7625 
7626     /* User code for call/n5/retR . */
7627 
7628     const jitter_uint in_arity = JITTER_ARGN0;
7629     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
7630     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
7631 
7632     if (c->kind == jitterlisp_closure_type_compiled)
7633       {
7634         /* Make place for the return address in the return stack.  The
7635            actual value will be written by the callee. */
7636         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
7637 
7638         /* Branch-and-link to the native code, whose first instruction
7639            will be a prolog. */
7640         struct jitterlisp_compiled_closure *cc = & c->compiled;
7641         JITTER_BRANCH_AND_LINK(cc->first_program_point);
7642       }
7643     else
7644       {
7645         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
7646 
7647         /* Push an element on the main stack.  This way we can ensure that
7648            every actual is accessible thru memory in a contiguous array,
7649            even if the main stack is TOS-optimized.  Compute the address
7650            (on the main stack backing) where the actuals begin.
7651 
7652            Notice that the interpreted function we are calling is allowed
7653            to call into compiled code in its turn.  This is not a problem,
7654            as we are not moving stack pointers down until the call ends:
7655            the unused part of the main and return stacks is available to
7656            the callee. */
7657         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
7658         jitterlisp_object *actuals
7659           // FIXME: add a stack operator to compute this address.
7660           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
7661 
7662         /* Call the interpreter. */
7663         jitterlisp_object interpretation_result
7664           = jitterlisp_call_interpreted (ic, actuals, in_arity);
7665 
7666         /* Remove as many elements as the in-arity plus one (the callee) from
7667            the stack, without affecting the top.  Unless JITTER_ARGN0 is
7668            residual this whole loops compiles to one instruction when the main
7669            stack is TOS-optimized, and doesn't touch memory. */
7670         int i;
7671         for (i = 0; i < in_arity + 1; i ++)
7672           JITTER_NIP_MAINSTACK();
7673 
7674         /* Now the stack is one element higher than it was before the call,
7675            containing the unspecified element at the top.  Replace it with
7676            the result.  Again this doesn't touch memory. */
7677         JITTER_TOP_MAINSTACK() = interpretation_result;
7678       }
7679 
7680     /* End of the user code for call/n5/retR . */
7681 
7682 /* User-specified code, instruction-end-c part: beginning. */
7683 
7684 
7685 /* User-specified code, instruction-end-c part: end */
7686 
7687     /* Undefine macros only visible in caller instructions. */
7688 #   undef JITTER_BRANCH_AND_LINK
7689 #   undef JITTER_BRANCH_FAST_AND_LINK
7690 
7691     /* Undefine the call/n5/retR argument macros so they can't be used
7692        by mistake in the instruction body coming next. */
7693 #   undef JITTER_SLOW_REGISTER_OFFSET0
7694 #   undef JITTER_ARG0
7695 #   undef JITTER_ARGN0
7696 #   undef JITTER_ARGU0
7697 #   undef JITTER_ARGP0
7698 #   undef JITTER_ARGF0
7699 #   undef JITTER_SLOW_REGISTER_OFFSET1
7700 #   undef JITTER_ARG1
7701 #   undef JITTER_ARGN1
7702 #   undef JITTER_ARGU1
7703 #   undef JITTER_ARGP1
7704 #   undef JITTER_ARGF1
7705 
7706 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7707 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7708 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7709 
7710   }
7711 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7712     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7713 # undef JITTER_RETURN_ADDRESS
7714 #endif
7715 
7716  JITTER_INSTRUCTION_EPILOG_(call/n5/retR, call__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7717 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7718 
7719   JITTER_INSTRUCTION_PROLOG_(call/n6/retR, call__n6__retR, hot)
7720   {
7721     /* This specialized instruction is not a replacement. */
7722 #   undef JITTER_BRANCH_FAST
7723 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7724 #   undef JITTER_BRANCH_FAST_IF_ZERO
7725 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7726 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7727 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7728 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7729 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7730 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7731 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7732 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7733 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7734 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7735 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7736 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7737 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7738 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7739 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7740 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7741 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7742 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7743 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7744 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7745 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7746 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7747 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7748 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7749 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7750 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7751 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7752 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7753 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7754 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7755 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7756 #   undef JITTER_BRANCH_FAST_IF_AND
7757 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7758 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7759 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7760 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7761 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7762 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7763 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7764 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7765 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
7766 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7767 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
7768 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7769 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
7770 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7771 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
7772 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7773 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7774 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7775 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
7776 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7777 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
7778 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7779 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
7780 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7781 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
7782 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7783 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
7784 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7785 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
7786     /* This specialized instruction is a caller.
7787        Its 1-th argument, a literal, is the return address where to jump
7788        back after the procedure returns.  Branch-and-link
7789        functionality is enabled for this instruction. */
7790 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
7791 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
7792 
7793 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       32
7794 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n6/retR
7795 
7796 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n6__retR
7797 
7798   /* The residual arity for this instruction does not depend on fast labels. */
7799   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
7800 
7801     /* The 0th argument is a nonresidual literal. */
7802 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
7803 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
7804 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
7805 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
7806 #   define JITTER_ARGF0 JITTER_ARGP0
7807 
7808     /* The 1th argument is a residual literal. */
7809 #if defined(JITTER_DISPATCH_NO_THREADING)
7810 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
7811     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
7812 #elif defined (JITTER_REPLICATE)
7813 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
7814 #else
7815 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
7816 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
7817 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
7818 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
7819 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
7820 #   define JITTER_ARGF1 JITTER_ARGP1
7821 
7822 
7823 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7824     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7825   /* We use the implicit atgument at the end of the calling.
7826      instruction to discover the procedure return address. */
7827   const void * _jitter_return_pointer = JITTER_ARGP1;
7828   /* And make it accessible to the user (who will usually call
7829      JITTER_BRANCH_AND_LINK) thru a nice macro. */
7830 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
7831 #endif
7832 
7833 #if defined (JITTER_PROFILE_SAMPLE)
7834   JITTER_PROFILE_SAMPLE_UPDATE
7835      (JITTERLISPVM_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      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
7853       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
7854 #endif
7855 
7856 /* User-specified code, instruction-beginning-c part: beginning. */
7857 
7858 
7859 /* User-specified code, instruction-beginning-c part: end */
7860 
7861 
7862     /* User code for call/n6/retR . */
7863 
7864     const jitter_uint in_arity = JITTER_ARGN0;
7865     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
7866     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
7867 
7868     if (c->kind == jitterlisp_closure_type_compiled)
7869       {
7870         /* Make place for the return address in the return stack.  The
7871            actual value will be written by the callee. */
7872         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
7873 
7874         /* Branch-and-link to the native code, whose first instruction
7875            will be a prolog. */
7876         struct jitterlisp_compiled_closure *cc = & c->compiled;
7877         JITTER_BRANCH_AND_LINK(cc->first_program_point);
7878       }
7879     else
7880       {
7881         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
7882 
7883         /* Push an element on the main stack.  This way we can ensure that
7884            every actual is accessible thru memory in a contiguous array,
7885            even if the main stack is TOS-optimized.  Compute the address
7886            (on the main stack backing) where the actuals begin.
7887 
7888            Notice that the interpreted function we are calling is allowed
7889            to call into compiled code in its turn.  This is not a problem,
7890            as we are not moving stack pointers down until the call ends:
7891            the unused part of the main and return stacks is available to
7892            the callee. */
7893         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
7894         jitterlisp_object *actuals
7895           // FIXME: add a stack operator to compute this address.
7896           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
7897 
7898         /* Call the interpreter. */
7899         jitterlisp_object interpretation_result
7900           = jitterlisp_call_interpreted (ic, actuals, in_arity);
7901 
7902         /* Remove as many elements as the in-arity plus one (the callee) from
7903            the stack, without affecting the top.  Unless JITTER_ARGN0 is
7904            residual this whole loops compiles to one instruction when the main
7905            stack is TOS-optimized, and doesn't touch memory. */
7906         int i;
7907         for (i = 0; i < in_arity + 1; i ++)
7908           JITTER_NIP_MAINSTACK();
7909 
7910         /* Now the stack is one element higher than it was before the call,
7911            containing the unspecified element at the top.  Replace it with
7912            the result.  Again this doesn't touch memory. */
7913         JITTER_TOP_MAINSTACK() = interpretation_result;
7914       }
7915 
7916     /* End of the user code for call/n6/retR . */
7917 
7918 /* User-specified code, instruction-end-c part: beginning. */
7919 
7920 
7921 /* User-specified code, instruction-end-c part: end */
7922 
7923     /* Undefine macros only visible in caller instructions. */
7924 #   undef JITTER_BRANCH_AND_LINK
7925 #   undef JITTER_BRANCH_FAST_AND_LINK
7926 
7927     /* Undefine the call/n6/retR argument macros so they can't be used
7928        by mistake in the instruction body coming next. */
7929 #   undef JITTER_SLOW_REGISTER_OFFSET0
7930 #   undef JITTER_ARG0
7931 #   undef JITTER_ARGN0
7932 #   undef JITTER_ARGU0
7933 #   undef JITTER_ARGP0
7934 #   undef JITTER_ARGF0
7935 #   undef JITTER_SLOW_REGISTER_OFFSET1
7936 #   undef JITTER_ARG1
7937 #   undef JITTER_ARGN1
7938 #   undef JITTER_ARGU1
7939 #   undef JITTER_ARGP1
7940 #   undef JITTER_ARGF1
7941 
7942 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
7943 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
7944 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
7945 
7946   }
7947 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
7948     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
7949 # undef JITTER_RETURN_ADDRESS
7950 #endif
7951 
7952  JITTER_INSTRUCTION_EPILOG_(call/n6/retR, call__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
7953 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
7954 
7955   JITTER_INSTRUCTION_PROLOG_(call/n7/retR, call__n7__retR, hot)
7956   {
7957     /* This specialized instruction is not a replacement. */
7958 #   undef JITTER_BRANCH_FAST
7959 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
7960 #   undef JITTER_BRANCH_FAST_IF_ZERO
7961 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
7962 #   undef JITTER_BRANCH_FAST_IF_NONZERO
7963 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
7964 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
7965 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
7966 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
7967 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
7968 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
7969 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
7970 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
7971 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
7972 #   undef JITTER_BRANCH_FAST_IF_EQUAL
7973 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
7974 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
7975 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
7976 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
7977 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
7978 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7979 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
7980 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7981 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
7982 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7983 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
7984 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7985 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
7986 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7987 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
7988 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7989 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
7990 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7991 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
7992 #   undef JITTER_BRANCH_FAST_IF_AND
7993 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
7994 #   undef JITTER_BRANCH_FAST_IF_NOTAND
7995 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
7996 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7997 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
7998 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
7999 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8000 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8001 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8002 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8003 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8004 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8005 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8006 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8007 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8008 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8009 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8010 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8011 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8012 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8013 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8014 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8015 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8016 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8017 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8018 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8019 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8020 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8021 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8022     /* This specialized instruction is a caller.
8023        Its 1-th argument, a literal, is the return address where to jump
8024        back after the procedure returns.  Branch-and-link
8025        functionality is enabled for this instruction. */
8026 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
8027 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8028 
8029 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       33
8030 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n7/retR
8031 
8032 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n7__retR
8033 
8034   /* The residual arity for this instruction does not depend on fast labels. */
8035   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
8036 
8037     /* The 0th argument is a nonresidual literal. */
8038 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
8039 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
8040 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
8041 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
8042 #   define JITTER_ARGF0 JITTER_ARGP0
8043 
8044     /* The 1th argument is a residual literal. */
8045 #if defined(JITTER_DISPATCH_NO_THREADING)
8046 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
8047     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
8048 #elif defined (JITTER_REPLICATE)
8049 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
8050 #else
8051 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
8052 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
8053 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
8054 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
8055 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
8056 #   define JITTER_ARGF1 JITTER_ARGP1
8057 
8058 
8059 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8060     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8061   /* We use the implicit atgument at the end of the calling.
8062      instruction to discover the procedure return address. */
8063   const void * _jitter_return_pointer = JITTER_ARGP1;
8064   /* And make it accessible to the user (who will usually call
8065      JITTER_BRANCH_AND_LINK) thru a nice macro. */
8066 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
8067 #endif
8068 
8069 #if defined (JITTER_PROFILE_SAMPLE)
8070   JITTER_PROFILE_SAMPLE_UPDATE
8071      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8072       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8073   /* Force the compiler not move sample-profiling instrumentation
8074      beyond this point; this way the actual user code is timed.
8075      This is still not perfect, as residuals are materialised before
8076      we arrive here, but should be adequate at least for slow VM
8077      instructions. */
8078   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8079 #endif
8080 #if defined (JITTER_PROFILE_COUNT)
8081   /* Notice that, differently from the code above, this
8082      instrumentation code *can* be reordered freely: as long as a
8083      VM instruction is counted, the count increment can be placed
8084      anyehere.  Let GCC move this code and possibly achieve better
8085      throughput by exploiting instruction-level parallelism and
8086      therefore approximate more closely a non-profiled build. */
8087   JITTER_PROFILE_COUNT_UPDATE
8088      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8089       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8090 #endif
8091 
8092 /* User-specified code, instruction-beginning-c part: beginning. */
8093 
8094 
8095 /* User-specified code, instruction-beginning-c part: end */
8096 
8097 
8098     /* User code for call/n7/retR . */
8099 
8100     const jitter_uint in_arity = JITTER_ARGN0;
8101     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
8102     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
8103 
8104     if (c->kind == jitterlisp_closure_type_compiled)
8105       {
8106         /* Make place for the return address in the return stack.  The
8107            actual value will be written by the callee. */
8108         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
8109 
8110         /* Branch-and-link to the native code, whose first instruction
8111            will be a prolog. */
8112         struct jitterlisp_compiled_closure *cc = & c->compiled;
8113         JITTER_BRANCH_AND_LINK(cc->first_program_point);
8114       }
8115     else
8116       {
8117         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
8118 
8119         /* Push an element on the main stack.  This way we can ensure that
8120            every actual is accessible thru memory in a contiguous array,
8121            even if the main stack is TOS-optimized.  Compute the address
8122            (on the main stack backing) where the actuals begin.
8123 
8124            Notice that the interpreted function we are calling is allowed
8125            to call into compiled code in its turn.  This is not a problem,
8126            as we are not moving stack pointers down until the call ends:
8127            the unused part of the main and return stacks is available to
8128            the callee. */
8129         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
8130         jitterlisp_object *actuals
8131           // FIXME: add a stack operator to compute this address.
8132           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
8133 
8134         /* Call the interpreter. */
8135         jitterlisp_object interpretation_result
8136           = jitterlisp_call_interpreted (ic, actuals, in_arity);
8137 
8138         /* Remove as many elements as the in-arity plus one (the callee) from
8139            the stack, without affecting the top.  Unless JITTER_ARGN0 is
8140            residual this whole loops compiles to one instruction when the main
8141            stack is TOS-optimized, and doesn't touch memory. */
8142         int i;
8143         for (i = 0; i < in_arity + 1; i ++)
8144           JITTER_NIP_MAINSTACK();
8145 
8146         /* Now the stack is one element higher than it was before the call,
8147            containing the unspecified element at the top.  Replace it with
8148            the result.  Again this doesn't touch memory. */
8149         JITTER_TOP_MAINSTACK() = interpretation_result;
8150       }
8151 
8152     /* End of the user code for call/n7/retR . */
8153 
8154 /* User-specified code, instruction-end-c part: beginning. */
8155 
8156 
8157 /* User-specified code, instruction-end-c part: end */
8158 
8159     /* Undefine macros only visible in caller instructions. */
8160 #   undef JITTER_BRANCH_AND_LINK
8161 #   undef JITTER_BRANCH_FAST_AND_LINK
8162 
8163     /* Undefine the call/n7/retR argument macros so they can't be used
8164        by mistake in the instruction body coming next. */
8165 #   undef JITTER_SLOW_REGISTER_OFFSET0
8166 #   undef JITTER_ARG0
8167 #   undef JITTER_ARGN0
8168 #   undef JITTER_ARGU0
8169 #   undef JITTER_ARGP0
8170 #   undef JITTER_ARGF0
8171 #   undef JITTER_SLOW_REGISTER_OFFSET1
8172 #   undef JITTER_ARG1
8173 #   undef JITTER_ARGN1
8174 #   undef JITTER_ARGU1
8175 #   undef JITTER_ARGP1
8176 #   undef JITTER_ARGF1
8177 
8178 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8179 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8180 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8181 
8182   }
8183 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8184     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8185 # undef JITTER_RETURN_ADDRESS
8186 #endif
8187 
8188  JITTER_INSTRUCTION_EPILOG_(call/n7/retR, call__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8189 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8190 
8191   JITTER_INSTRUCTION_PROLOG_(call/n8/retR, call__n8__retR, hot)
8192   {
8193     /* This specialized instruction is not a replacement. */
8194 #   undef JITTER_BRANCH_FAST
8195 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8196 #   undef JITTER_BRANCH_FAST_IF_ZERO
8197 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8198 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8199 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8200 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8201 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8202 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8203 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8204 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8205 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8206 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8207 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8208 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8209 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8210 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8211 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8212 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8213 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8214 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8215 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8216 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8217 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8218 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8219 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8220 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8221 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8222 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8223 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8224 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8225 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8226 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8227 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8228 #   undef JITTER_BRANCH_FAST_IF_AND
8229 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8230 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8231 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8232 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8233 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8234 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8235 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8236 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8237 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8238 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8239 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8240 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8241 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8242 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8243 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8244 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8245 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8246 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8247 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8248 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8249 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8250 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8251 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8252 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8253 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8254 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8255 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8256 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8257 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8258     /* This specialized instruction is a caller.
8259        Its 1-th argument, a literal, is the return address where to jump
8260        back after the procedure returns.  Branch-and-link
8261        functionality is enabled for this instruction. */
8262 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
8263 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8264 
8265 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       34
8266 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n8/retR
8267 
8268 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n8__retR
8269 
8270   /* The residual arity for this instruction does not depend on fast labels. */
8271   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
8272 
8273     /* The 0th argument is a nonresidual literal. */
8274 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
8275 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
8276 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
8277 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
8278 #   define JITTER_ARGF0 JITTER_ARGP0
8279 
8280     /* The 1th argument is a residual literal. */
8281 #if defined(JITTER_DISPATCH_NO_THREADING)
8282 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
8283     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
8284 #elif defined (JITTER_REPLICATE)
8285 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
8286 #else
8287 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
8288 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
8289 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
8290 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
8291 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
8292 #   define JITTER_ARGF1 JITTER_ARGP1
8293 
8294 
8295 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8296     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8297   /* We use the implicit atgument at the end of the calling.
8298      instruction to discover the procedure return address. */
8299   const void * _jitter_return_pointer = JITTER_ARGP1;
8300   /* And make it accessible to the user (who will usually call
8301      JITTER_BRANCH_AND_LINK) thru a nice macro. */
8302 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
8303 #endif
8304 
8305 #if defined (JITTER_PROFILE_SAMPLE)
8306   JITTER_PROFILE_SAMPLE_UPDATE
8307      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8308       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8309   /* Force the compiler not move sample-profiling instrumentation
8310      beyond this point; this way the actual user code is timed.
8311      This is still not perfect, as residuals are materialised before
8312      we arrive here, but should be adequate at least for slow VM
8313      instructions. */
8314   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8315 #endif
8316 #if defined (JITTER_PROFILE_COUNT)
8317   /* Notice that, differently from the code above, this
8318      instrumentation code *can* be reordered freely: as long as a
8319      VM instruction is counted, the count increment can be placed
8320      anyehere.  Let GCC move this code and possibly achieve better
8321      throughput by exploiting instruction-level parallelism and
8322      therefore approximate more closely a non-profiled build. */
8323   JITTER_PROFILE_COUNT_UPDATE
8324      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8325       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8326 #endif
8327 
8328 /* User-specified code, instruction-beginning-c part: beginning. */
8329 
8330 
8331 /* User-specified code, instruction-beginning-c part: end */
8332 
8333 
8334     /* User code for call/n8/retR . */
8335 
8336     const jitter_uint in_arity = JITTER_ARGN0;
8337     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
8338     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
8339 
8340     if (c->kind == jitterlisp_closure_type_compiled)
8341       {
8342         /* Make place for the return address in the return stack.  The
8343            actual value will be written by the callee. */
8344         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
8345 
8346         /* Branch-and-link to the native code, whose first instruction
8347            will be a prolog. */
8348         struct jitterlisp_compiled_closure *cc = & c->compiled;
8349         JITTER_BRANCH_AND_LINK(cc->first_program_point);
8350       }
8351     else
8352       {
8353         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
8354 
8355         /* Push an element on the main stack.  This way we can ensure that
8356            every actual is accessible thru memory in a contiguous array,
8357            even if the main stack is TOS-optimized.  Compute the address
8358            (on the main stack backing) where the actuals begin.
8359 
8360            Notice that the interpreted function we are calling is allowed
8361            to call into compiled code in its turn.  This is not a problem,
8362            as we are not moving stack pointers down until the call ends:
8363            the unused part of the main and return stacks is available to
8364            the callee. */
8365         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
8366         jitterlisp_object *actuals
8367           // FIXME: add a stack operator to compute this address.
8368           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
8369 
8370         /* Call the interpreter. */
8371         jitterlisp_object interpretation_result
8372           = jitterlisp_call_interpreted (ic, actuals, in_arity);
8373 
8374         /* Remove as many elements as the in-arity plus one (the callee) from
8375            the stack, without affecting the top.  Unless JITTER_ARGN0 is
8376            residual this whole loops compiles to one instruction when the main
8377            stack is TOS-optimized, and doesn't touch memory. */
8378         int i;
8379         for (i = 0; i < in_arity + 1; i ++)
8380           JITTER_NIP_MAINSTACK();
8381 
8382         /* Now the stack is one element higher than it was before the call,
8383            containing the unspecified element at the top.  Replace it with
8384            the result.  Again this doesn't touch memory. */
8385         JITTER_TOP_MAINSTACK() = interpretation_result;
8386       }
8387 
8388     /* End of the user code for call/n8/retR . */
8389 
8390 /* User-specified code, instruction-end-c part: beginning. */
8391 
8392 
8393 /* User-specified code, instruction-end-c part: end */
8394 
8395     /* Undefine macros only visible in caller instructions. */
8396 #   undef JITTER_BRANCH_AND_LINK
8397 #   undef JITTER_BRANCH_FAST_AND_LINK
8398 
8399     /* Undefine the call/n8/retR argument macros so they can't be used
8400        by mistake in the instruction body coming next. */
8401 #   undef JITTER_SLOW_REGISTER_OFFSET0
8402 #   undef JITTER_ARG0
8403 #   undef JITTER_ARGN0
8404 #   undef JITTER_ARGU0
8405 #   undef JITTER_ARGP0
8406 #   undef JITTER_ARGF0
8407 #   undef JITTER_SLOW_REGISTER_OFFSET1
8408 #   undef JITTER_ARG1
8409 #   undef JITTER_ARGN1
8410 #   undef JITTER_ARGU1
8411 #   undef JITTER_ARGP1
8412 #   undef JITTER_ARGF1
8413 
8414 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8415 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8416 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8417 
8418   }
8419 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8420     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8421 # undef JITTER_RETURN_ADDRESS
8422 #endif
8423 
8424  JITTER_INSTRUCTION_EPILOG_(call/n8/retR, call__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8425 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8426 
8427   JITTER_INSTRUCTION_PROLOG_(call/n9/retR, call__n9__retR, hot)
8428   {
8429     /* This specialized instruction is not a replacement. */
8430 #   undef JITTER_BRANCH_FAST
8431 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8432 #   undef JITTER_BRANCH_FAST_IF_ZERO
8433 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8434 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8435 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8436 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8437 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8438 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8439 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8440 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8441 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8442 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8443 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8444 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8445 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8446 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8447 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8448 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8449 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8450 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8451 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8452 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8453 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8454 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8455 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8456 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8457 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8458 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8459 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8460 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8461 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8462 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8463 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8464 #   undef JITTER_BRANCH_FAST_IF_AND
8465 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8466 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8467 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8468 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8469 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8470 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8471 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8472 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8473 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8474 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8475 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8476 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8477 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8478 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8479 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8480 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8481 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8482 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8483 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8484 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8485 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8486 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8487 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8488 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8489 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8490 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8491 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8492 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8493 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8494     /* This specialized instruction is a caller.
8495        Its 1-th argument, a literal, is the return address where to jump
8496        back after the procedure returns.  Branch-and-link
8497        functionality is enabled for this instruction. */
8498 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
8499 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8500 
8501 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       35
8502 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n9/retR
8503 
8504 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n9__retR
8505 
8506   /* The residual arity for this instruction does not depend on fast labels. */
8507   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
8508 
8509     /* The 0th argument is a nonresidual literal. */
8510 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
8511 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
8512 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
8513 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
8514 #   define JITTER_ARGF0 JITTER_ARGP0
8515 
8516     /* The 1th argument is a residual literal. */
8517 #if defined(JITTER_DISPATCH_NO_THREADING)
8518 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
8519     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
8520 #elif defined (JITTER_REPLICATE)
8521 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
8522 #else
8523 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
8524 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
8525 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
8526 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
8527 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
8528 #   define JITTER_ARGF1 JITTER_ARGP1
8529 
8530 
8531 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8532     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8533   /* We use the implicit atgument at the end of the calling.
8534      instruction to discover the procedure return address. */
8535   const void * _jitter_return_pointer = JITTER_ARGP1;
8536   /* And make it accessible to the user (who will usually call
8537      JITTER_BRANCH_AND_LINK) thru a nice macro. */
8538 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
8539 #endif
8540 
8541 #if defined (JITTER_PROFILE_SAMPLE)
8542   JITTER_PROFILE_SAMPLE_UPDATE
8543      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8544       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8545   /* Force the compiler not move sample-profiling instrumentation
8546      beyond this point; this way the actual user code is timed.
8547      This is still not perfect, as residuals are materialised before
8548      we arrive here, but should be adequate at least for slow VM
8549      instructions. */
8550   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8551 #endif
8552 #if defined (JITTER_PROFILE_COUNT)
8553   /* Notice that, differently from the code above, this
8554      instrumentation code *can* be reordered freely: as long as a
8555      VM instruction is counted, the count increment can be placed
8556      anyehere.  Let GCC move this code and possibly achieve better
8557      throughput by exploiting instruction-level parallelism and
8558      therefore approximate more closely a non-profiled build. */
8559   JITTER_PROFILE_COUNT_UPDATE
8560      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8561       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8562 #endif
8563 
8564 /* User-specified code, instruction-beginning-c part: beginning. */
8565 
8566 
8567 /* User-specified code, instruction-beginning-c part: end */
8568 
8569 
8570     /* User code for call/n9/retR . */
8571 
8572     const jitter_uint in_arity = JITTER_ARGN0;
8573     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
8574     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
8575 
8576     if (c->kind == jitterlisp_closure_type_compiled)
8577       {
8578         /* Make place for the return address in the return stack.  The
8579            actual value will be written by the callee. */
8580         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
8581 
8582         /* Branch-and-link to the native code, whose first instruction
8583            will be a prolog. */
8584         struct jitterlisp_compiled_closure *cc = & c->compiled;
8585         JITTER_BRANCH_AND_LINK(cc->first_program_point);
8586       }
8587     else
8588       {
8589         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
8590 
8591         /* Push an element on the main stack.  This way we can ensure that
8592            every actual is accessible thru memory in a contiguous array,
8593            even if the main stack is TOS-optimized.  Compute the address
8594            (on the main stack backing) where the actuals begin.
8595 
8596            Notice that the interpreted function we are calling is allowed
8597            to call into compiled code in its turn.  This is not a problem,
8598            as we are not moving stack pointers down until the call ends:
8599            the unused part of the main and return stacks is available to
8600            the callee. */
8601         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
8602         jitterlisp_object *actuals
8603           // FIXME: add a stack operator to compute this address.
8604           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
8605 
8606         /* Call the interpreter. */
8607         jitterlisp_object interpretation_result
8608           = jitterlisp_call_interpreted (ic, actuals, in_arity);
8609 
8610         /* Remove as many elements as the in-arity plus one (the callee) from
8611            the stack, without affecting the top.  Unless JITTER_ARGN0 is
8612            residual this whole loops compiles to one instruction when the main
8613            stack is TOS-optimized, and doesn't touch memory. */
8614         int i;
8615         for (i = 0; i < in_arity + 1; i ++)
8616           JITTER_NIP_MAINSTACK();
8617 
8618         /* Now the stack is one element higher than it was before the call,
8619            containing the unspecified element at the top.  Replace it with
8620            the result.  Again this doesn't touch memory. */
8621         JITTER_TOP_MAINSTACK() = interpretation_result;
8622       }
8623 
8624     /* End of the user code for call/n9/retR . */
8625 
8626 /* User-specified code, instruction-end-c part: beginning. */
8627 
8628 
8629 /* User-specified code, instruction-end-c part: end */
8630 
8631     /* Undefine macros only visible in caller instructions. */
8632 #   undef JITTER_BRANCH_AND_LINK
8633 #   undef JITTER_BRANCH_FAST_AND_LINK
8634 
8635     /* Undefine the call/n9/retR argument macros so they can't be used
8636        by mistake in the instruction body coming next. */
8637 #   undef JITTER_SLOW_REGISTER_OFFSET0
8638 #   undef JITTER_ARG0
8639 #   undef JITTER_ARGN0
8640 #   undef JITTER_ARGU0
8641 #   undef JITTER_ARGP0
8642 #   undef JITTER_ARGF0
8643 #   undef JITTER_SLOW_REGISTER_OFFSET1
8644 #   undef JITTER_ARG1
8645 #   undef JITTER_ARGN1
8646 #   undef JITTER_ARGU1
8647 #   undef JITTER_ARGP1
8648 #   undef JITTER_ARGF1
8649 
8650 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8651 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8652 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8653 
8654   }
8655 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8656     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8657 # undef JITTER_RETURN_ADDRESS
8658 #endif
8659 
8660  JITTER_INSTRUCTION_EPILOG_(call/n9/retR, call__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8661 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8662 
8663   JITTER_INSTRUCTION_PROLOG_(call/n10/retR, call__n10__retR, hot)
8664   {
8665     /* This specialized instruction is not a replacement. */
8666 #   undef JITTER_BRANCH_FAST
8667 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8668 #   undef JITTER_BRANCH_FAST_IF_ZERO
8669 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8670 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8671 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8672 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8673 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8674 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8675 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8676 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8677 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8678 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8679 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8680 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8681 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8682 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8683 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8684 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8685 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8686 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8687 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8688 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8689 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8690 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8691 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8692 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8693 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8694 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8695 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8696 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8697 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8698 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8699 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8700 #   undef JITTER_BRANCH_FAST_IF_AND
8701 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8702 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8703 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8704 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8705 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8706 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8707 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8708 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8709 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8710 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8711 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8712 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8713 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8714 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8715 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8716 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8717 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8718 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8719 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8720 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8721 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8722 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8723 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8724 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8725 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8726 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8727 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8728 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8729 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8730     /* This specialized instruction is a caller.
8731        Its 1-th argument, a literal, is the return address where to jump
8732        back after the procedure returns.  Branch-and-link
8733        functionality is enabled for this instruction. */
8734 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
8735 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8736 
8737 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       36
8738 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/n10/retR
8739 
8740 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__n10__retR
8741 
8742   /* The residual arity for this instruction does not depend on fast labels. */
8743   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
8744 
8745     /* The 0th argument is a nonresidual literal. */
8746 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
8747 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
8748 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
8749 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
8750 #   define JITTER_ARGF0 JITTER_ARGP0
8751 
8752     /* The 1th argument is a residual literal. */
8753 #if defined(JITTER_DISPATCH_NO_THREADING)
8754 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
8755     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
8756 #elif defined (JITTER_REPLICATE)
8757 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
8758 #else
8759 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
8760 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
8761 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
8762 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
8763 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
8764 #   define JITTER_ARGF1 JITTER_ARGP1
8765 
8766 
8767 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8768     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8769   /* We use the implicit atgument at the end of the calling.
8770      instruction to discover the procedure return address. */
8771   const void * _jitter_return_pointer = JITTER_ARGP1;
8772   /* And make it accessible to the user (who will usually call
8773      JITTER_BRANCH_AND_LINK) thru a nice macro. */
8774 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
8775 #endif
8776 
8777 #if defined (JITTER_PROFILE_SAMPLE)
8778   JITTER_PROFILE_SAMPLE_UPDATE
8779      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8780       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8781   /* Force the compiler not move sample-profiling instrumentation
8782      beyond this point; this way the actual user code is timed.
8783      This is still not perfect, as residuals are materialised before
8784      we arrive here, but should be adequate at least for slow VM
8785      instructions. */
8786   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
8787 #endif
8788 #if defined (JITTER_PROFILE_COUNT)
8789   /* Notice that, differently from the code above, this
8790      instrumentation code *can* be reordered freely: as long as a
8791      VM instruction is counted, the count increment can be placed
8792      anyehere.  Let GCC move this code and possibly achieve better
8793      throughput by exploiting instruction-level parallelism and
8794      therefore approximate more closely a non-profiled build. */
8795   JITTER_PROFILE_COUNT_UPDATE
8796      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
8797       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
8798 #endif
8799 
8800 /* User-specified code, instruction-beginning-c part: beginning. */
8801 
8802 
8803 /* User-specified code, instruction-beginning-c part: end */
8804 
8805 
8806     /* User code for call/n10/retR . */
8807 
8808     const jitter_uint in_arity = JITTER_ARGN0;
8809     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
8810     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
8811 
8812     if (c->kind == jitterlisp_closure_type_compiled)
8813       {
8814         /* Make place for the return address in the return stack.  The
8815            actual value will be written by the callee. */
8816         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
8817 
8818         /* Branch-and-link to the native code, whose first instruction
8819            will be a prolog. */
8820         struct jitterlisp_compiled_closure *cc = & c->compiled;
8821         JITTER_BRANCH_AND_LINK(cc->first_program_point);
8822       }
8823     else
8824       {
8825         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
8826 
8827         /* Push an element on the main stack.  This way we can ensure that
8828            every actual is accessible thru memory in a contiguous array,
8829            even if the main stack is TOS-optimized.  Compute the address
8830            (on the main stack backing) where the actuals begin.
8831 
8832            Notice that the interpreted function we are calling is allowed
8833            to call into compiled code in its turn.  This is not a problem,
8834            as we are not moving stack pointers down until the call ends:
8835            the unused part of the main and return stacks is available to
8836            the callee. */
8837         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
8838         jitterlisp_object *actuals
8839           // FIXME: add a stack operator to compute this address.
8840           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
8841 
8842         /* Call the interpreter. */
8843         jitterlisp_object interpretation_result
8844           = jitterlisp_call_interpreted (ic, actuals, in_arity);
8845 
8846         /* Remove as many elements as the in-arity plus one (the callee) from
8847            the stack, without affecting the top.  Unless JITTER_ARGN0 is
8848            residual this whole loops compiles to one instruction when the main
8849            stack is TOS-optimized, and doesn't touch memory. */
8850         int i;
8851         for (i = 0; i < in_arity + 1; i ++)
8852           JITTER_NIP_MAINSTACK();
8853 
8854         /* Now the stack is one element higher than it was before the call,
8855            containing the unspecified element at the top.  Replace it with
8856            the result.  Again this doesn't touch memory. */
8857         JITTER_TOP_MAINSTACK() = interpretation_result;
8858       }
8859 
8860     /* End of the user code for call/n10/retR . */
8861 
8862 /* User-specified code, instruction-end-c part: beginning. */
8863 
8864 
8865 /* User-specified code, instruction-end-c part: end */
8866 
8867     /* Undefine macros only visible in caller instructions. */
8868 #   undef JITTER_BRANCH_AND_LINK
8869 #   undef JITTER_BRANCH_FAST_AND_LINK
8870 
8871     /* Undefine the call/n10/retR argument macros so they can't be used
8872        by mistake in the instruction body coming next. */
8873 #   undef JITTER_SLOW_REGISTER_OFFSET0
8874 #   undef JITTER_ARG0
8875 #   undef JITTER_ARGN0
8876 #   undef JITTER_ARGU0
8877 #   undef JITTER_ARGP0
8878 #   undef JITTER_ARGF0
8879 #   undef JITTER_SLOW_REGISTER_OFFSET1
8880 #   undef JITTER_ARG1
8881 #   undef JITTER_ARGN1
8882 #   undef JITTER_ARGU1
8883 #   undef JITTER_ARGP1
8884 #   undef JITTER_ARGF1
8885 
8886 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
8887 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
8888 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
8889 
8890   }
8891 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
8892     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
8893 # undef JITTER_RETURN_ADDRESS
8894 #endif
8895 
8896  JITTER_INSTRUCTION_EPILOG_(call/n10/retR, call__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
8897 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
8898 
8899   JITTER_INSTRUCTION_PROLOG_(call/nR/retR, call__nR__retR, cold)
8900   {
8901     /* This specialized instruction is not a replacement. */
8902 #   undef JITTER_BRANCH_FAST
8903 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
8904 #   undef JITTER_BRANCH_FAST_IF_ZERO
8905 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
8906 #   undef JITTER_BRANCH_FAST_IF_NONZERO
8907 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
8908 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
8909 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
8910 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
8911 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
8912 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
8913 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
8914 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
8915 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
8916 #   undef JITTER_BRANCH_FAST_IF_EQUAL
8917 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
8918 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
8919 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
8920 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
8921 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
8922 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8923 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
8924 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8925 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
8926 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8927 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
8928 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8929 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
8930 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8931 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
8932 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8933 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
8934 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8935 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
8936 #   undef JITTER_BRANCH_FAST_IF_AND
8937 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
8938 #   undef JITTER_BRANCH_FAST_IF_NOTAND
8939 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
8940 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8941 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
8942 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8943 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
8944 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8945 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
8946 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8947 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
8948 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8949 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
8950 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8951 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
8952 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8953 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8954 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8955 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
8956 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8957 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
8958 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8959 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
8960 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8961 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
8962 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8963 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
8964 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8965 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
8966     /* This specialized instruction is a caller.
8967        Its 1-th argument, a literal, is the return address where to jump
8968        back after the procedure returns.  Branch-and-link
8969        functionality is enabled for this instruction. */
8970 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
8971 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
8972 
8973 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       37
8974 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call/nR/retR
8975 
8976 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call__nR__retR
8977 
8978   /* The residual arity for this instruction does not depend on fast labels. */
8979   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
8980 
8981     /* The 0th argument is a residual literal. */
8982 #if defined(JITTER_DISPATCH_NO_THREADING)
8983 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
8984     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
8985 #elif defined (JITTER_REPLICATE)
8986 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
8987 #else
8988 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
8989 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
8990 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
8991 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
8992 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
8993 #   define JITTER_ARGF0 JITTER_ARGP0
8994 
8995     /* The 1th argument is a residual literal. */
8996 #if defined(JITTER_DISPATCH_NO_THREADING)
8997 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
8998     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
8999 #elif defined (JITTER_REPLICATE)
9000 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
9001 #else
9002 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
9003 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9004 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
9005 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
9006 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
9007 #   define JITTER_ARGF1 JITTER_ARGP1
9008 
9009 
9010 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9011     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9012   /* We use the implicit atgument at the end of the calling.
9013      instruction to discover the procedure return address. */
9014   const void * _jitter_return_pointer = JITTER_ARGP1;
9015   /* And make it accessible to the user (who will usually call
9016      JITTER_BRANCH_AND_LINK) thru a nice macro. */
9017 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
9018 #endif
9019 
9020 #if defined (JITTER_PROFILE_SAMPLE)
9021   JITTER_PROFILE_SAMPLE_UPDATE
9022      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9023       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9024   /* Force the compiler not move sample-profiling instrumentation
9025      beyond this point; this way the actual user code is timed.
9026      This is still not perfect, as residuals are materialised before
9027      we arrive here, but should be adequate at least for slow VM
9028      instructions. */
9029   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9030 #endif
9031 #if defined (JITTER_PROFILE_COUNT)
9032   /* Notice that, differently from the code above, this
9033      instrumentation code *can* be reordered freely: as long as a
9034      VM instruction is counted, the count increment can be placed
9035      anyehere.  Let GCC move this code and possibly achieve better
9036      throughput by exploiting instruction-level parallelism and
9037      therefore approximate more closely a non-profiled build. */
9038   JITTER_PROFILE_COUNT_UPDATE
9039      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9040       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9041 #endif
9042 
9043 /* User-specified code, instruction-beginning-c part: beginning. */
9044 
9045 
9046 /* User-specified code, instruction-beginning-c part: end */
9047 
9048 
9049     /* User code for call/nR/retR . */
9050 
9051     const jitter_uint in_arity = JITTER_ARGN0;
9052     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
9053     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
9054 
9055     if (c->kind == jitterlisp_closure_type_compiled)
9056       {
9057         /* Make place for the return address in the return stack.  The
9058            actual value will be written by the callee. */
9059         JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
9060 
9061         /* Branch-and-link to the native code, whose first instruction
9062            will be a prolog. */
9063         struct jitterlisp_compiled_closure *cc = & c->compiled;
9064         JITTER_BRANCH_AND_LINK(cc->first_program_point);
9065       }
9066     else
9067       {
9068         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
9069 
9070         /* Push an element on the main stack.  This way we can ensure that
9071            every actual is accessible thru memory in a contiguous array,
9072            even if the main stack is TOS-optimized.  Compute the address
9073            (on the main stack backing) where the actuals begin.
9074 
9075            Notice that the interpreted function we are calling is allowed
9076            to call into compiled code in its turn.  This is not a problem,
9077            as we are not moving stack pointers down until the call ends:
9078            the unused part of the main and return stacks is available to
9079            the callee. */
9080         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
9081         jitterlisp_object *actuals
9082           // FIXME: add a stack operator to compute this address.
9083           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
9084 
9085         /* Call the interpreter. */
9086         jitterlisp_object interpretation_result
9087           = jitterlisp_call_interpreted (ic, actuals, in_arity);
9088 
9089         /* Remove as many elements as the in-arity plus one (the callee) from
9090            the stack, without affecting the top.  Unless JITTER_ARGN0 is
9091            residual this whole loops compiles to one instruction when the main
9092            stack is TOS-optimized, and doesn't touch memory. */
9093         int i;
9094         for (i = 0; i < in_arity + 1; i ++)
9095           JITTER_NIP_MAINSTACK();
9096 
9097         /* Now the stack is one element higher than it was before the call,
9098            containing the unspecified element at the top.  Replace it with
9099            the result.  Again this doesn't touch memory. */
9100         JITTER_TOP_MAINSTACK() = interpretation_result;
9101       }
9102 
9103     /* End of the user code for call/nR/retR . */
9104 
9105 /* User-specified code, instruction-end-c part: beginning. */
9106 
9107 
9108 /* User-specified code, instruction-end-c part: end */
9109 
9110     /* Undefine macros only visible in caller instructions. */
9111 #   undef JITTER_BRANCH_AND_LINK
9112 #   undef JITTER_BRANCH_FAST_AND_LINK
9113 
9114     /* Undefine the call/nR/retR argument macros so they can't be used
9115        by mistake in the instruction body coming next. */
9116 #   undef JITTER_SLOW_REGISTER_OFFSET0
9117 #   undef JITTER_ARG0
9118 #   undef JITTER_ARGN0
9119 #   undef JITTER_ARGU0
9120 #   undef JITTER_ARGP0
9121 #   undef JITTER_ARGF0
9122 #   undef JITTER_SLOW_REGISTER_OFFSET1
9123 #   undef JITTER_ARG1
9124 #   undef JITTER_ARGN1
9125 #   undef JITTER_ARGU1
9126 #   undef JITTER_ARGP1
9127 #   undef JITTER_ARGF1
9128 
9129 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9130 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9131 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9132 
9133   }
9134 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9135     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9136 # undef JITTER_RETURN_ADDRESS
9137 #endif
9138 
9139  JITTER_INSTRUCTION_EPILOG_(call/nR/retR, call__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9140 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9141 
9142   JITTER_INSTRUCTION_PROLOG_(call-compiled/n0/retR, call_mcompiled__n0__retR, hot)
9143   {
9144     /* This specialized instruction is not a replacement. */
9145 #   undef JITTER_BRANCH_FAST
9146 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9147 #   undef JITTER_BRANCH_FAST_IF_ZERO
9148 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9149 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9150 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9151 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9152 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9153 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9154 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9155 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9156 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9157 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9158 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9159 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9160 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9161 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9162 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9163 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9164 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9165 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9166 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9167 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9168 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9169 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9170 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9171 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9172 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9173 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9174 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9175 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9176 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9177 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9178 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9179 #   undef JITTER_BRANCH_FAST_IF_AND
9180 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9181 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9182 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9183 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9184 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9185 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9186 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9187 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9188 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9189 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9190 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9191 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9192 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9193 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9194 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9195 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9196 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9197 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9198 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9199 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9200 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9201 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9202 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9203 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9204 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9205 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9206 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9207 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9208 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9209     /* This specialized instruction is a caller.
9210        Its 1-th argument, a literal, is the return address where to jump
9211        back after the procedure returns.  Branch-and-link
9212        functionality is enabled for this instruction. */
9213 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
9214 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9215 
9216 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       38
9217 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n0/retR
9218 
9219 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n0__retR
9220 
9221   /* The residual arity for this instruction does not depend on fast labels. */
9222   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9223 
9224     /* The 0th argument is a nonresidual literal. */
9225 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
9226 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9227 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9228 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9229 #   define JITTER_ARGF0 JITTER_ARGP0
9230 
9231     /* The 1th argument is a residual literal. */
9232 #if defined(JITTER_DISPATCH_NO_THREADING)
9233 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
9234     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9235 #elif defined (JITTER_REPLICATE)
9236 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
9237 #else
9238 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
9239 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9240 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
9241 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
9242 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
9243 #   define JITTER_ARGF1 JITTER_ARGP1
9244 
9245 
9246 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9247     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9248   /* We use the implicit atgument at the end of the calling.
9249      instruction to discover the procedure return address. */
9250   const void * _jitter_return_pointer = JITTER_ARGP1;
9251   /* And make it accessible to the user (who will usually call
9252      JITTER_BRANCH_AND_LINK) thru a nice macro. */
9253 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
9254 #endif
9255 
9256 #if defined (JITTER_PROFILE_SAMPLE)
9257   JITTER_PROFILE_SAMPLE_UPDATE
9258      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9259       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9260   /* Force the compiler not move sample-profiling instrumentation
9261      beyond this point; this way the actual user code is timed.
9262      This is still not perfect, as residuals are materialised before
9263      we arrive here, but should be adequate at least for slow VM
9264      instructions. */
9265   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9266 #endif
9267 #if defined (JITTER_PROFILE_COUNT)
9268   /* Notice that, differently from the code above, this
9269      instrumentation code *can* be reordered freely: as long as a
9270      VM instruction is counted, the count increment can be placed
9271      anyehere.  Let GCC move this code and possibly achieve better
9272      throughput by exploiting instruction-level parallelism and
9273      therefore approximate more closely a non-profiled build. */
9274   JITTER_PROFILE_COUNT_UPDATE
9275      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9276       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9277 #endif
9278 
9279 /* User-specified code, instruction-beginning-c part: beginning. */
9280 
9281 
9282 /* User-specified code, instruction-beginning-c part: end */
9283 
9284 
9285     /* User code for call-compiled/n0/retR . */
9286 
9287     const jitter_uint in_arity = JITTER_ARGN0;
9288     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
9289     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
9290 
9291     /* Here we can assume that * c is a compiled closure without checking. */
9292     struct jitterlisp_compiled_closure *cc = & c->compiled;
9293 
9294     /* Make place for the return address in the return stack.  The
9295        actual value will be written by the callee. */
9296     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
9297 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
9298 
9299     /* Branch-and-link to the native code, whose first instruction
9300        will be a prolog. */
9301     JITTER_BRANCH_AND_LINK(cc->first_program_point);
9302 
9303     /* End of the user code for call-compiled/n0/retR . */
9304 
9305 /* User-specified code, instruction-end-c part: beginning. */
9306 
9307 
9308 /* User-specified code, instruction-end-c part: end */
9309 
9310     /* Undefine macros only visible in caller instructions. */
9311 #   undef JITTER_BRANCH_AND_LINK
9312 #   undef JITTER_BRANCH_FAST_AND_LINK
9313 
9314     /* Undefine the call-compiled/n0/retR argument macros so they can't be used
9315        by mistake in the instruction body coming next. */
9316 #   undef JITTER_SLOW_REGISTER_OFFSET0
9317 #   undef JITTER_ARG0
9318 #   undef JITTER_ARGN0
9319 #   undef JITTER_ARGU0
9320 #   undef JITTER_ARGP0
9321 #   undef JITTER_ARGF0
9322 #   undef JITTER_SLOW_REGISTER_OFFSET1
9323 #   undef JITTER_ARG1
9324 #   undef JITTER_ARGN1
9325 #   undef JITTER_ARGU1
9326 #   undef JITTER_ARGP1
9327 #   undef JITTER_ARGF1
9328 
9329 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9330 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9331 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9332 
9333   }
9334 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9335     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9336 # undef JITTER_RETURN_ADDRESS
9337 #endif
9338 
9339  JITTER_INSTRUCTION_EPILOG_(call-compiled/n0/retR, call_mcompiled__n0__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9340 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9341 
9342   JITTER_INSTRUCTION_PROLOG_(call-compiled/n1/retR, call_mcompiled__n1__retR, hot)
9343   {
9344     /* This specialized instruction is not a replacement. */
9345 #   undef JITTER_BRANCH_FAST
9346 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9347 #   undef JITTER_BRANCH_FAST_IF_ZERO
9348 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9349 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9350 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9351 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9352 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9353 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9354 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9355 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9356 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9357 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9358 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9359 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9360 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9361 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9362 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9363 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9364 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9365 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9366 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9367 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9368 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9369 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9370 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9371 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9372 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9373 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9374 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9375 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9376 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9377 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9378 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9379 #   undef JITTER_BRANCH_FAST_IF_AND
9380 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9381 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9382 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9383 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9384 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9385 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9386 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9387 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9388 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9389 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9390 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9391 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9392 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9393 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9394 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9395 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9396 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9397 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9398 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9399 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9400 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9401 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9402 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9403 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9404 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9405 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9406 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9407 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9408 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9409     /* This specialized instruction is a caller.
9410        Its 1-th argument, a literal, is the return address where to jump
9411        back after the procedure returns.  Branch-and-link
9412        functionality is enabled for this instruction. */
9413 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
9414 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9415 
9416 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       39
9417 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n1/retR
9418 
9419 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n1__retR
9420 
9421   /* The residual arity for this instruction does not depend on fast labels. */
9422   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9423 
9424     /* The 0th argument is a nonresidual literal. */
9425 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
9426 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9427 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9428 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9429 #   define JITTER_ARGF0 JITTER_ARGP0
9430 
9431     /* The 1th argument is a residual literal. */
9432 #if defined(JITTER_DISPATCH_NO_THREADING)
9433 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
9434     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9435 #elif defined (JITTER_REPLICATE)
9436 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
9437 #else
9438 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
9439 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9440 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
9441 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
9442 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
9443 #   define JITTER_ARGF1 JITTER_ARGP1
9444 
9445 
9446 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9447     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9448   /* We use the implicit atgument at the end of the calling.
9449      instruction to discover the procedure return address. */
9450   const void * _jitter_return_pointer = JITTER_ARGP1;
9451   /* And make it accessible to the user (who will usually call
9452      JITTER_BRANCH_AND_LINK) thru a nice macro. */
9453 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
9454 #endif
9455 
9456 #if defined (JITTER_PROFILE_SAMPLE)
9457   JITTER_PROFILE_SAMPLE_UPDATE
9458      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9459       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9460   /* Force the compiler not move sample-profiling instrumentation
9461      beyond this point; this way the actual user code is timed.
9462      This is still not perfect, as residuals are materialised before
9463      we arrive here, but should be adequate at least for slow VM
9464      instructions. */
9465   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9466 #endif
9467 #if defined (JITTER_PROFILE_COUNT)
9468   /* Notice that, differently from the code above, this
9469      instrumentation code *can* be reordered freely: as long as a
9470      VM instruction is counted, the count increment can be placed
9471      anyehere.  Let GCC move this code and possibly achieve better
9472      throughput by exploiting instruction-level parallelism and
9473      therefore approximate more closely a non-profiled build. */
9474   JITTER_PROFILE_COUNT_UPDATE
9475      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9476       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9477 #endif
9478 
9479 /* User-specified code, instruction-beginning-c part: beginning. */
9480 
9481 
9482 /* User-specified code, instruction-beginning-c part: end */
9483 
9484 
9485     /* User code for call-compiled/n1/retR . */
9486 
9487     const jitter_uint in_arity = JITTER_ARGN0;
9488     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
9489     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
9490 
9491     /* Here we can assume that * c is a compiled closure without checking. */
9492     struct jitterlisp_compiled_closure *cc = & c->compiled;
9493 
9494     /* Make place for the return address in the return stack.  The
9495        actual value will be written by the callee. */
9496     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
9497 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
9498 
9499     /* Branch-and-link to the native code, whose first instruction
9500        will be a prolog. */
9501     JITTER_BRANCH_AND_LINK(cc->first_program_point);
9502 
9503     /* End of the user code for call-compiled/n1/retR . */
9504 
9505 /* User-specified code, instruction-end-c part: beginning. */
9506 
9507 
9508 /* User-specified code, instruction-end-c part: end */
9509 
9510     /* Undefine macros only visible in caller instructions. */
9511 #   undef JITTER_BRANCH_AND_LINK
9512 #   undef JITTER_BRANCH_FAST_AND_LINK
9513 
9514     /* Undefine the call-compiled/n1/retR argument macros so they can't be used
9515        by mistake in the instruction body coming next. */
9516 #   undef JITTER_SLOW_REGISTER_OFFSET0
9517 #   undef JITTER_ARG0
9518 #   undef JITTER_ARGN0
9519 #   undef JITTER_ARGU0
9520 #   undef JITTER_ARGP0
9521 #   undef JITTER_ARGF0
9522 #   undef JITTER_SLOW_REGISTER_OFFSET1
9523 #   undef JITTER_ARG1
9524 #   undef JITTER_ARGN1
9525 #   undef JITTER_ARGU1
9526 #   undef JITTER_ARGP1
9527 #   undef JITTER_ARGF1
9528 
9529 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9530 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9531 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9532 
9533   }
9534 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9535     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9536 # undef JITTER_RETURN_ADDRESS
9537 #endif
9538 
9539  JITTER_INSTRUCTION_EPILOG_(call-compiled/n1/retR, call_mcompiled__n1__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9540 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9541 
9542   JITTER_INSTRUCTION_PROLOG_(call-compiled/n2/retR, call_mcompiled__n2__retR, hot)
9543   {
9544     /* This specialized instruction is not a replacement. */
9545 #   undef JITTER_BRANCH_FAST
9546 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9547 #   undef JITTER_BRANCH_FAST_IF_ZERO
9548 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9549 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9550 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9551 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9552 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9553 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9554 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9555 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9556 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9557 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9558 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9559 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9560 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9561 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9562 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9563 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9564 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9565 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9566 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9567 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9568 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9569 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9570 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9571 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9572 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9573 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9574 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9575 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9576 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9577 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9578 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9579 #   undef JITTER_BRANCH_FAST_IF_AND
9580 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9581 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9582 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9583 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9584 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9585 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9586 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9587 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9588 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9589 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9590 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9591 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9592 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9593 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9594 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9595 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9596 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9597 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9598 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9599 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9600 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9601 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9602 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9603 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9604 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9605 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9606 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9607 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9608 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9609     /* This specialized instruction is a caller.
9610        Its 1-th argument, a literal, is the return address where to jump
9611        back after the procedure returns.  Branch-and-link
9612        functionality is enabled for this instruction. */
9613 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
9614 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9615 
9616 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       40
9617 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n2/retR
9618 
9619 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n2__retR
9620 
9621   /* The residual arity for this instruction does not depend on fast labels. */
9622   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9623 
9624     /* The 0th argument is a nonresidual literal. */
9625 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
9626 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9627 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9628 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9629 #   define JITTER_ARGF0 JITTER_ARGP0
9630 
9631     /* The 1th argument is a residual literal. */
9632 #if defined(JITTER_DISPATCH_NO_THREADING)
9633 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
9634     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9635 #elif defined (JITTER_REPLICATE)
9636 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
9637 #else
9638 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
9639 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9640 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
9641 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
9642 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
9643 #   define JITTER_ARGF1 JITTER_ARGP1
9644 
9645 
9646 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9647     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9648   /* We use the implicit atgument at the end of the calling.
9649      instruction to discover the procedure return address. */
9650   const void * _jitter_return_pointer = JITTER_ARGP1;
9651   /* And make it accessible to the user (who will usually call
9652      JITTER_BRANCH_AND_LINK) thru a nice macro. */
9653 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
9654 #endif
9655 
9656 #if defined (JITTER_PROFILE_SAMPLE)
9657   JITTER_PROFILE_SAMPLE_UPDATE
9658      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9659       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9660   /* Force the compiler not move sample-profiling instrumentation
9661      beyond this point; this way the actual user code is timed.
9662      This is still not perfect, as residuals are materialised before
9663      we arrive here, but should be adequate at least for slow VM
9664      instructions. */
9665   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9666 #endif
9667 #if defined (JITTER_PROFILE_COUNT)
9668   /* Notice that, differently from the code above, this
9669      instrumentation code *can* be reordered freely: as long as a
9670      VM instruction is counted, the count increment can be placed
9671      anyehere.  Let GCC move this code and possibly achieve better
9672      throughput by exploiting instruction-level parallelism and
9673      therefore approximate more closely a non-profiled build. */
9674   JITTER_PROFILE_COUNT_UPDATE
9675      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9676       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9677 #endif
9678 
9679 /* User-specified code, instruction-beginning-c part: beginning. */
9680 
9681 
9682 /* User-specified code, instruction-beginning-c part: end */
9683 
9684 
9685     /* User code for call-compiled/n2/retR . */
9686 
9687     const jitter_uint in_arity = JITTER_ARGN0;
9688     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
9689     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
9690 
9691     /* Here we can assume that * c is a compiled closure without checking. */
9692     struct jitterlisp_compiled_closure *cc = & c->compiled;
9693 
9694     /* Make place for the return address in the return stack.  The
9695        actual value will be written by the callee. */
9696     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
9697 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
9698 
9699     /* Branch-and-link to the native code, whose first instruction
9700        will be a prolog. */
9701     JITTER_BRANCH_AND_LINK(cc->first_program_point);
9702 
9703     /* End of the user code for call-compiled/n2/retR . */
9704 
9705 /* User-specified code, instruction-end-c part: beginning. */
9706 
9707 
9708 /* User-specified code, instruction-end-c part: end */
9709 
9710     /* Undefine macros only visible in caller instructions. */
9711 #   undef JITTER_BRANCH_AND_LINK
9712 #   undef JITTER_BRANCH_FAST_AND_LINK
9713 
9714     /* Undefine the call-compiled/n2/retR argument macros so they can't be used
9715        by mistake in the instruction body coming next. */
9716 #   undef JITTER_SLOW_REGISTER_OFFSET0
9717 #   undef JITTER_ARG0
9718 #   undef JITTER_ARGN0
9719 #   undef JITTER_ARGU0
9720 #   undef JITTER_ARGP0
9721 #   undef JITTER_ARGF0
9722 #   undef JITTER_SLOW_REGISTER_OFFSET1
9723 #   undef JITTER_ARG1
9724 #   undef JITTER_ARGN1
9725 #   undef JITTER_ARGU1
9726 #   undef JITTER_ARGP1
9727 #   undef JITTER_ARGF1
9728 
9729 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9730 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9731 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9732 
9733   }
9734 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9735     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9736 # undef JITTER_RETURN_ADDRESS
9737 #endif
9738 
9739  JITTER_INSTRUCTION_EPILOG_(call-compiled/n2/retR, call_mcompiled__n2__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9740 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9741 
9742   JITTER_INSTRUCTION_PROLOG_(call-compiled/n3/retR, call_mcompiled__n3__retR, hot)
9743   {
9744     /* This specialized instruction is not a replacement. */
9745 #   undef JITTER_BRANCH_FAST
9746 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9747 #   undef JITTER_BRANCH_FAST_IF_ZERO
9748 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9749 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9750 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9751 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9752 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9753 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9754 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9755 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9756 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9757 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9758 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9759 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9760 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9761 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9762 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9763 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9764 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9765 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9766 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9767 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9768 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9769 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9770 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9771 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9772 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9773 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9774 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9775 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9776 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9777 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9778 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9779 #   undef JITTER_BRANCH_FAST_IF_AND
9780 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9781 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9782 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9783 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9784 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9785 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9786 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9787 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9788 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9789 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9790 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9791 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9792 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9793 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9794 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9795 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9796 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9797 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9798 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9799 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9800 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
9801 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9802 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
9803 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9804 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
9805 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9806 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
9807 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9808 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
9809     /* This specialized instruction is a caller.
9810        Its 1-th argument, a literal, is the return address where to jump
9811        back after the procedure returns.  Branch-and-link
9812        functionality is enabled for this instruction. */
9813 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
9814 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9815 
9816 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       41
9817 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n3/retR
9818 
9819 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n3__retR
9820 
9821   /* The residual arity for this instruction does not depend on fast labels. */
9822   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
9823 
9824     /* The 0th argument is a nonresidual literal. */
9825 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
9826 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
9827 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
9828 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
9829 #   define JITTER_ARGF0 JITTER_ARGP0
9830 
9831     /* The 1th argument is a residual literal. */
9832 #if defined(JITTER_DISPATCH_NO_THREADING)
9833 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
9834     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
9835 #elif defined (JITTER_REPLICATE)
9836 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
9837 #else
9838 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
9839 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
9840 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
9841 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
9842 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
9843 #   define JITTER_ARGF1 JITTER_ARGP1
9844 
9845 
9846 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9847     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9848   /* We use the implicit atgument at the end of the calling.
9849      instruction to discover the procedure return address. */
9850   const void * _jitter_return_pointer = JITTER_ARGP1;
9851   /* And make it accessible to the user (who will usually call
9852      JITTER_BRANCH_AND_LINK) thru a nice macro. */
9853 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
9854 #endif
9855 
9856 #if defined (JITTER_PROFILE_SAMPLE)
9857   JITTER_PROFILE_SAMPLE_UPDATE
9858      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9859       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9860   /* Force the compiler not move sample-profiling instrumentation
9861      beyond this point; this way the actual user code is timed.
9862      This is still not perfect, as residuals are materialised before
9863      we arrive here, but should be adequate at least for slow VM
9864      instructions. */
9865   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
9866 #endif
9867 #if defined (JITTER_PROFILE_COUNT)
9868   /* Notice that, differently from the code above, this
9869      instrumentation code *can* be reordered freely: as long as a
9870      VM instruction is counted, the count increment can be placed
9871      anyehere.  Let GCC move this code and possibly achieve better
9872      throughput by exploiting instruction-level parallelism and
9873      therefore approximate more closely a non-profiled build. */
9874   JITTER_PROFILE_COUNT_UPDATE
9875      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
9876       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
9877 #endif
9878 
9879 /* User-specified code, instruction-beginning-c part: beginning. */
9880 
9881 
9882 /* User-specified code, instruction-beginning-c part: end */
9883 
9884 
9885     /* User code for call-compiled/n3/retR . */
9886 
9887     const jitter_uint in_arity = JITTER_ARGN0;
9888     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
9889     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
9890 
9891     /* Here we can assume that * c is a compiled closure without checking. */
9892     struct jitterlisp_compiled_closure *cc = & c->compiled;
9893 
9894     /* Make place for the return address in the return stack.  The
9895        actual value will be written by the callee. */
9896     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
9897 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
9898 
9899     /* Branch-and-link to the native code, whose first instruction
9900        will be a prolog. */
9901     JITTER_BRANCH_AND_LINK(cc->first_program_point);
9902 
9903     /* End of the user code for call-compiled/n3/retR . */
9904 
9905 /* User-specified code, instruction-end-c part: beginning. */
9906 
9907 
9908 /* User-specified code, instruction-end-c part: end */
9909 
9910     /* Undefine macros only visible in caller instructions. */
9911 #   undef JITTER_BRANCH_AND_LINK
9912 #   undef JITTER_BRANCH_FAST_AND_LINK
9913 
9914     /* Undefine the call-compiled/n3/retR argument macros so they can't be used
9915        by mistake in the instruction body coming next. */
9916 #   undef JITTER_SLOW_REGISTER_OFFSET0
9917 #   undef JITTER_ARG0
9918 #   undef JITTER_ARGN0
9919 #   undef JITTER_ARGU0
9920 #   undef JITTER_ARGP0
9921 #   undef JITTER_ARGF0
9922 #   undef JITTER_SLOW_REGISTER_OFFSET1
9923 #   undef JITTER_ARG1
9924 #   undef JITTER_ARGN1
9925 #   undef JITTER_ARGU1
9926 #   undef JITTER_ARGP1
9927 #   undef JITTER_ARGF1
9928 
9929 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
9930 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
9931 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
9932 
9933   }
9934 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
9935     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
9936 # undef JITTER_RETURN_ADDRESS
9937 #endif
9938 
9939  JITTER_INSTRUCTION_EPILOG_(call-compiled/n3/retR, call_mcompiled__n3__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
9940 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
9941 
9942   JITTER_INSTRUCTION_PROLOG_(call-compiled/n4/retR, call_mcompiled__n4__retR, hot)
9943   {
9944     /* This specialized instruction is not a replacement. */
9945 #   undef JITTER_BRANCH_FAST
9946 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
9947 #   undef JITTER_BRANCH_FAST_IF_ZERO
9948 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
9949 #   undef JITTER_BRANCH_FAST_IF_NONZERO
9950 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
9951 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
9952 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
9953 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
9954 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
9955 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
9956 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
9957 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
9958 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
9959 #   undef JITTER_BRANCH_FAST_IF_EQUAL
9960 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
9961 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
9962 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
9963 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
9964 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
9965 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9966 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
9967 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9968 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
9969 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9970 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
9971 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9972 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
9973 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9974 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
9975 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9976 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
9977 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9978 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
9979 #   undef JITTER_BRANCH_FAST_IF_AND
9980 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
9981 #   undef JITTER_BRANCH_FAST_IF_NOTAND
9982 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
9983 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9984 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
9985 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9986 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
9987 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9988 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
9989 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9990 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
9991 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9992 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
9993 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9994 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
9995 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9996 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
9997 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9998 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
9999 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10000 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10001 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10002 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10003 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10004 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10005 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10006 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10007 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10008 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10009     /* This specialized instruction is a caller.
10010        Its 1-th argument, a literal, is the return address where to jump
10011        back after the procedure returns.  Branch-and-link
10012        functionality is enabled for this instruction. */
10013 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
10014 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10015 
10016 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       42
10017 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n4/retR
10018 
10019 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n4__retR
10020 
10021   /* The residual arity for this instruction does not depend on fast labels. */
10022   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
10023 
10024     /* The 0th argument is a nonresidual literal. */
10025 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
10026 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
10027 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
10028 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
10029 #   define JITTER_ARGF0 JITTER_ARGP0
10030 
10031     /* The 1th argument is a residual literal. */
10032 #if defined(JITTER_DISPATCH_NO_THREADING)
10033 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
10034     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
10035 #elif defined (JITTER_REPLICATE)
10036 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
10037 #else
10038 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
10039 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
10040 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
10041 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
10042 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
10043 #   define JITTER_ARGF1 JITTER_ARGP1
10044 
10045 
10046 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10047     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10048   /* We use the implicit atgument at the end of the calling.
10049      instruction to discover the procedure return address. */
10050   const void * _jitter_return_pointer = JITTER_ARGP1;
10051   /* And make it accessible to the user (who will usually call
10052      JITTER_BRANCH_AND_LINK) thru a nice macro. */
10053 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
10054 #endif
10055 
10056 #if defined (JITTER_PROFILE_SAMPLE)
10057   JITTER_PROFILE_SAMPLE_UPDATE
10058      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10059       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10060   /* Force the compiler not move sample-profiling instrumentation
10061      beyond this point; this way the actual user code is timed.
10062      This is still not perfect, as residuals are materialised before
10063      we arrive here, but should be adequate at least for slow VM
10064      instructions. */
10065   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10066 #endif
10067 #if defined (JITTER_PROFILE_COUNT)
10068   /* Notice that, differently from the code above, this
10069      instrumentation code *can* be reordered freely: as long as a
10070      VM instruction is counted, the count increment can be placed
10071      anyehere.  Let GCC move this code and possibly achieve better
10072      throughput by exploiting instruction-level parallelism and
10073      therefore approximate more closely a non-profiled build. */
10074   JITTER_PROFILE_COUNT_UPDATE
10075      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10076       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10077 #endif
10078 
10079 /* User-specified code, instruction-beginning-c part: beginning. */
10080 
10081 
10082 /* User-specified code, instruction-beginning-c part: end */
10083 
10084 
10085     /* User code for call-compiled/n4/retR . */
10086 
10087     const jitter_uint in_arity = JITTER_ARGN0;
10088     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
10089     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
10090 
10091     /* Here we can assume that * c is a compiled closure without checking. */
10092     struct jitterlisp_compiled_closure *cc = & c->compiled;
10093 
10094     /* Make place for the return address in the return stack.  The
10095        actual value will be written by the callee. */
10096     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
10097 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
10098 
10099     /* Branch-and-link to the native code, whose first instruction
10100        will be a prolog. */
10101     JITTER_BRANCH_AND_LINK(cc->first_program_point);
10102 
10103     /* End of the user code for call-compiled/n4/retR . */
10104 
10105 /* User-specified code, instruction-end-c part: beginning. */
10106 
10107 
10108 /* User-specified code, instruction-end-c part: end */
10109 
10110     /* Undefine macros only visible in caller instructions. */
10111 #   undef JITTER_BRANCH_AND_LINK
10112 #   undef JITTER_BRANCH_FAST_AND_LINK
10113 
10114     /* Undefine the call-compiled/n4/retR argument macros so they can't be used
10115        by mistake in the instruction body coming next. */
10116 #   undef JITTER_SLOW_REGISTER_OFFSET0
10117 #   undef JITTER_ARG0
10118 #   undef JITTER_ARGN0
10119 #   undef JITTER_ARGU0
10120 #   undef JITTER_ARGP0
10121 #   undef JITTER_ARGF0
10122 #   undef JITTER_SLOW_REGISTER_OFFSET1
10123 #   undef JITTER_ARG1
10124 #   undef JITTER_ARGN1
10125 #   undef JITTER_ARGU1
10126 #   undef JITTER_ARGP1
10127 #   undef JITTER_ARGF1
10128 
10129 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10130 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10131 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10132 
10133   }
10134 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10135     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10136 # undef JITTER_RETURN_ADDRESS
10137 #endif
10138 
10139  JITTER_INSTRUCTION_EPILOG_(call-compiled/n4/retR, call_mcompiled__n4__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10140 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10141 
10142   JITTER_INSTRUCTION_PROLOG_(call-compiled/n5/retR, call_mcompiled__n5__retR, hot)
10143   {
10144     /* This specialized instruction is not a replacement. */
10145 #   undef JITTER_BRANCH_FAST
10146 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10147 #   undef JITTER_BRANCH_FAST_IF_ZERO
10148 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10149 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10150 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10151 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10152 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10153 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10154 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10155 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10156 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10157 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10158 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10159 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10160 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10161 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10162 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10163 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10164 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10165 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10166 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10167 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10168 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10169 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10170 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10171 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10172 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10173 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10174 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10175 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10176 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10177 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10178 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10179 #   undef JITTER_BRANCH_FAST_IF_AND
10180 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10181 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10182 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10183 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10184 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10185 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10186 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10187 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10188 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10189 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10190 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10191 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10192 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10193 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10194 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10195 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10196 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10197 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10198 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10199 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10200 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10201 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10202 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10203 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10204 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10205 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10206 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10207 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10208 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10209     /* This specialized instruction is a caller.
10210        Its 1-th argument, a literal, is the return address where to jump
10211        back after the procedure returns.  Branch-and-link
10212        functionality is enabled for this instruction. */
10213 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
10214 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10215 
10216 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       43
10217 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n5/retR
10218 
10219 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n5__retR
10220 
10221   /* The residual arity for this instruction does not depend on fast labels. */
10222   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
10223 
10224     /* The 0th argument is a nonresidual literal. */
10225 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
10226 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
10227 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
10228 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
10229 #   define JITTER_ARGF0 JITTER_ARGP0
10230 
10231     /* The 1th argument is a residual literal. */
10232 #if defined(JITTER_DISPATCH_NO_THREADING)
10233 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
10234     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
10235 #elif defined (JITTER_REPLICATE)
10236 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
10237 #else
10238 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
10239 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
10240 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
10241 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
10242 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
10243 #   define JITTER_ARGF1 JITTER_ARGP1
10244 
10245 
10246 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10247     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10248   /* We use the implicit atgument at the end of the calling.
10249      instruction to discover the procedure return address. */
10250   const void * _jitter_return_pointer = JITTER_ARGP1;
10251   /* And make it accessible to the user (who will usually call
10252      JITTER_BRANCH_AND_LINK) thru a nice macro. */
10253 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
10254 #endif
10255 
10256 #if defined (JITTER_PROFILE_SAMPLE)
10257   JITTER_PROFILE_SAMPLE_UPDATE
10258      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10259       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10260   /* Force the compiler not move sample-profiling instrumentation
10261      beyond this point; this way the actual user code is timed.
10262      This is still not perfect, as residuals are materialised before
10263      we arrive here, but should be adequate at least for slow VM
10264      instructions. */
10265   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10266 #endif
10267 #if defined (JITTER_PROFILE_COUNT)
10268   /* Notice that, differently from the code above, this
10269      instrumentation code *can* be reordered freely: as long as a
10270      VM instruction is counted, the count increment can be placed
10271      anyehere.  Let GCC move this code and possibly achieve better
10272      throughput by exploiting instruction-level parallelism and
10273      therefore approximate more closely a non-profiled build. */
10274   JITTER_PROFILE_COUNT_UPDATE
10275      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10276       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10277 #endif
10278 
10279 /* User-specified code, instruction-beginning-c part: beginning. */
10280 
10281 
10282 /* User-specified code, instruction-beginning-c part: end */
10283 
10284 
10285     /* User code for call-compiled/n5/retR . */
10286 
10287     const jitter_uint in_arity = JITTER_ARGN0;
10288     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
10289     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
10290 
10291     /* Here we can assume that * c is a compiled closure without checking. */
10292     struct jitterlisp_compiled_closure *cc = & c->compiled;
10293 
10294     /* Make place for the return address in the return stack.  The
10295        actual value will be written by the callee. */
10296     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
10297 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
10298 
10299     /* Branch-and-link to the native code, whose first instruction
10300        will be a prolog. */
10301     JITTER_BRANCH_AND_LINK(cc->first_program_point);
10302 
10303     /* End of the user code for call-compiled/n5/retR . */
10304 
10305 /* User-specified code, instruction-end-c part: beginning. */
10306 
10307 
10308 /* User-specified code, instruction-end-c part: end */
10309 
10310     /* Undefine macros only visible in caller instructions. */
10311 #   undef JITTER_BRANCH_AND_LINK
10312 #   undef JITTER_BRANCH_FAST_AND_LINK
10313 
10314     /* Undefine the call-compiled/n5/retR argument macros so they can't be used
10315        by mistake in the instruction body coming next. */
10316 #   undef JITTER_SLOW_REGISTER_OFFSET0
10317 #   undef JITTER_ARG0
10318 #   undef JITTER_ARGN0
10319 #   undef JITTER_ARGU0
10320 #   undef JITTER_ARGP0
10321 #   undef JITTER_ARGF0
10322 #   undef JITTER_SLOW_REGISTER_OFFSET1
10323 #   undef JITTER_ARG1
10324 #   undef JITTER_ARGN1
10325 #   undef JITTER_ARGU1
10326 #   undef JITTER_ARGP1
10327 #   undef JITTER_ARGF1
10328 
10329 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10330 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10331 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10332 
10333   }
10334 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10335     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10336 # undef JITTER_RETURN_ADDRESS
10337 #endif
10338 
10339  JITTER_INSTRUCTION_EPILOG_(call-compiled/n5/retR, call_mcompiled__n5__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10340 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10341 
10342   JITTER_INSTRUCTION_PROLOG_(call-compiled/n6/retR, call_mcompiled__n6__retR, hot)
10343   {
10344     /* This specialized instruction is not a replacement. */
10345 #   undef JITTER_BRANCH_FAST
10346 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10347 #   undef JITTER_BRANCH_FAST_IF_ZERO
10348 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10349 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10350 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10351 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10352 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10353 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10354 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10355 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10356 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10357 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10358 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10359 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10360 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10361 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10362 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10363 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10364 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10365 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10366 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10367 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10368 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10369 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10370 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10371 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10372 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10373 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10374 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10375 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10376 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10377 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10378 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10379 #   undef JITTER_BRANCH_FAST_IF_AND
10380 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10381 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10382 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10383 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10384 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10385 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10386 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10387 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10388 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10389 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10390 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10391 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10392 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10393 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10394 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10395 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10396 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10397 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10398 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10399 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10400 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10401 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10402 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10403 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10404 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10405 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10406 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10407 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10408 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10409     /* This specialized instruction is a caller.
10410        Its 1-th argument, a literal, is the return address where to jump
10411        back after the procedure returns.  Branch-and-link
10412        functionality is enabled for this instruction. */
10413 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
10414 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10415 
10416 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       44
10417 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n6/retR
10418 
10419 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n6__retR
10420 
10421   /* The residual arity for this instruction does not depend on fast labels. */
10422   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
10423 
10424     /* The 0th argument is a nonresidual literal. */
10425 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
10426 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
10427 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
10428 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
10429 #   define JITTER_ARGF0 JITTER_ARGP0
10430 
10431     /* The 1th argument is a residual literal. */
10432 #if defined(JITTER_DISPATCH_NO_THREADING)
10433 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
10434     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
10435 #elif defined (JITTER_REPLICATE)
10436 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
10437 #else
10438 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
10439 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
10440 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
10441 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
10442 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
10443 #   define JITTER_ARGF1 JITTER_ARGP1
10444 
10445 
10446 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10447     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10448   /* We use the implicit atgument at the end of the calling.
10449      instruction to discover the procedure return address. */
10450   const void * _jitter_return_pointer = JITTER_ARGP1;
10451   /* And make it accessible to the user (who will usually call
10452      JITTER_BRANCH_AND_LINK) thru a nice macro. */
10453 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
10454 #endif
10455 
10456 #if defined (JITTER_PROFILE_SAMPLE)
10457   JITTER_PROFILE_SAMPLE_UPDATE
10458      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10459       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10460   /* Force the compiler not move sample-profiling instrumentation
10461      beyond this point; this way the actual user code is timed.
10462      This is still not perfect, as residuals are materialised before
10463      we arrive here, but should be adequate at least for slow VM
10464      instructions. */
10465   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10466 #endif
10467 #if defined (JITTER_PROFILE_COUNT)
10468   /* Notice that, differently from the code above, this
10469      instrumentation code *can* be reordered freely: as long as a
10470      VM instruction is counted, the count increment can be placed
10471      anyehere.  Let GCC move this code and possibly achieve better
10472      throughput by exploiting instruction-level parallelism and
10473      therefore approximate more closely a non-profiled build. */
10474   JITTER_PROFILE_COUNT_UPDATE
10475      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10476       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10477 #endif
10478 
10479 /* User-specified code, instruction-beginning-c part: beginning. */
10480 
10481 
10482 /* User-specified code, instruction-beginning-c part: end */
10483 
10484 
10485     /* User code for call-compiled/n6/retR . */
10486 
10487     const jitter_uint in_arity = JITTER_ARGN0;
10488     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
10489     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
10490 
10491     /* Here we can assume that * c is a compiled closure without checking. */
10492     struct jitterlisp_compiled_closure *cc = & c->compiled;
10493 
10494     /* Make place for the return address in the return stack.  The
10495        actual value will be written by the callee. */
10496     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
10497 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
10498 
10499     /* Branch-and-link to the native code, whose first instruction
10500        will be a prolog. */
10501     JITTER_BRANCH_AND_LINK(cc->first_program_point);
10502 
10503     /* End of the user code for call-compiled/n6/retR . */
10504 
10505 /* User-specified code, instruction-end-c part: beginning. */
10506 
10507 
10508 /* User-specified code, instruction-end-c part: end */
10509 
10510     /* Undefine macros only visible in caller instructions. */
10511 #   undef JITTER_BRANCH_AND_LINK
10512 #   undef JITTER_BRANCH_FAST_AND_LINK
10513 
10514     /* Undefine the call-compiled/n6/retR argument macros so they can't be used
10515        by mistake in the instruction body coming next. */
10516 #   undef JITTER_SLOW_REGISTER_OFFSET0
10517 #   undef JITTER_ARG0
10518 #   undef JITTER_ARGN0
10519 #   undef JITTER_ARGU0
10520 #   undef JITTER_ARGP0
10521 #   undef JITTER_ARGF0
10522 #   undef JITTER_SLOW_REGISTER_OFFSET1
10523 #   undef JITTER_ARG1
10524 #   undef JITTER_ARGN1
10525 #   undef JITTER_ARGU1
10526 #   undef JITTER_ARGP1
10527 #   undef JITTER_ARGF1
10528 
10529 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10530 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10531 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10532 
10533   }
10534 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10535     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10536 # undef JITTER_RETURN_ADDRESS
10537 #endif
10538 
10539  JITTER_INSTRUCTION_EPILOG_(call-compiled/n6/retR, call_mcompiled__n6__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10540 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10541 
10542   JITTER_INSTRUCTION_PROLOG_(call-compiled/n7/retR, call_mcompiled__n7__retR, hot)
10543   {
10544     /* This specialized instruction is not a replacement. */
10545 #   undef JITTER_BRANCH_FAST
10546 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10547 #   undef JITTER_BRANCH_FAST_IF_ZERO
10548 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10549 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10550 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10551 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10552 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10553 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10554 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10555 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10556 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10557 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10558 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10559 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10560 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10561 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10562 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10563 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10564 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10565 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10566 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10567 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10568 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10569 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10570 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10571 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10572 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10573 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10574 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10575 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10576 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10577 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10578 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10579 #   undef JITTER_BRANCH_FAST_IF_AND
10580 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10581 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10582 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10583 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10584 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10585 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10586 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10587 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10588 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10589 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10590 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10591 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10592 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10593 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10594 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10595 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10596 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10597 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10598 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10599 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10600 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10601 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10602 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10603 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10604 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10605 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10606 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10607 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10608 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10609     /* This specialized instruction is a caller.
10610        Its 1-th argument, a literal, is the return address where to jump
10611        back after the procedure returns.  Branch-and-link
10612        functionality is enabled for this instruction. */
10613 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
10614 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10615 
10616 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       45
10617 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n7/retR
10618 
10619 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n7__retR
10620 
10621   /* The residual arity for this instruction does not depend on fast labels. */
10622   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
10623 
10624     /* The 0th argument is a nonresidual literal. */
10625 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
10626 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
10627 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
10628 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
10629 #   define JITTER_ARGF0 JITTER_ARGP0
10630 
10631     /* The 1th argument is a residual literal. */
10632 #if defined(JITTER_DISPATCH_NO_THREADING)
10633 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
10634     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
10635 #elif defined (JITTER_REPLICATE)
10636 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
10637 #else
10638 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
10639 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
10640 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
10641 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
10642 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
10643 #   define JITTER_ARGF1 JITTER_ARGP1
10644 
10645 
10646 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10647     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10648   /* We use the implicit atgument at the end of the calling.
10649      instruction to discover the procedure return address. */
10650   const void * _jitter_return_pointer = JITTER_ARGP1;
10651   /* And make it accessible to the user (who will usually call
10652      JITTER_BRANCH_AND_LINK) thru a nice macro. */
10653 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
10654 #endif
10655 
10656 #if defined (JITTER_PROFILE_SAMPLE)
10657   JITTER_PROFILE_SAMPLE_UPDATE
10658      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10659       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10660   /* Force the compiler not move sample-profiling instrumentation
10661      beyond this point; this way the actual user code is timed.
10662      This is still not perfect, as residuals are materialised before
10663      we arrive here, but should be adequate at least for slow VM
10664      instructions. */
10665   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10666 #endif
10667 #if defined (JITTER_PROFILE_COUNT)
10668   /* Notice that, differently from the code above, this
10669      instrumentation code *can* be reordered freely: as long as a
10670      VM instruction is counted, the count increment can be placed
10671      anyehere.  Let GCC move this code and possibly achieve better
10672      throughput by exploiting instruction-level parallelism and
10673      therefore approximate more closely a non-profiled build. */
10674   JITTER_PROFILE_COUNT_UPDATE
10675      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10676       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10677 #endif
10678 
10679 /* User-specified code, instruction-beginning-c part: beginning. */
10680 
10681 
10682 /* User-specified code, instruction-beginning-c part: end */
10683 
10684 
10685     /* User code for call-compiled/n7/retR . */
10686 
10687     const jitter_uint in_arity = JITTER_ARGN0;
10688     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
10689     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
10690 
10691     /* Here we can assume that * c is a compiled closure without checking. */
10692     struct jitterlisp_compiled_closure *cc = & c->compiled;
10693 
10694     /* Make place for the return address in the return stack.  The
10695        actual value will be written by the callee. */
10696     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
10697 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
10698 
10699     /* Branch-and-link to the native code, whose first instruction
10700        will be a prolog. */
10701     JITTER_BRANCH_AND_LINK(cc->first_program_point);
10702 
10703     /* End of the user code for call-compiled/n7/retR . */
10704 
10705 /* User-specified code, instruction-end-c part: beginning. */
10706 
10707 
10708 /* User-specified code, instruction-end-c part: end */
10709 
10710     /* Undefine macros only visible in caller instructions. */
10711 #   undef JITTER_BRANCH_AND_LINK
10712 #   undef JITTER_BRANCH_FAST_AND_LINK
10713 
10714     /* Undefine the call-compiled/n7/retR argument macros so they can't be used
10715        by mistake in the instruction body coming next. */
10716 #   undef JITTER_SLOW_REGISTER_OFFSET0
10717 #   undef JITTER_ARG0
10718 #   undef JITTER_ARGN0
10719 #   undef JITTER_ARGU0
10720 #   undef JITTER_ARGP0
10721 #   undef JITTER_ARGF0
10722 #   undef JITTER_SLOW_REGISTER_OFFSET1
10723 #   undef JITTER_ARG1
10724 #   undef JITTER_ARGN1
10725 #   undef JITTER_ARGU1
10726 #   undef JITTER_ARGP1
10727 #   undef JITTER_ARGF1
10728 
10729 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10730 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10731 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10732 
10733   }
10734 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10735     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10736 # undef JITTER_RETURN_ADDRESS
10737 #endif
10738 
10739  JITTER_INSTRUCTION_EPILOG_(call-compiled/n7/retR, call_mcompiled__n7__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10740 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10741 
10742   JITTER_INSTRUCTION_PROLOG_(call-compiled/n8/retR, call_mcompiled__n8__retR, hot)
10743   {
10744     /* This specialized instruction is not a replacement. */
10745 #   undef JITTER_BRANCH_FAST
10746 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10747 #   undef JITTER_BRANCH_FAST_IF_ZERO
10748 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10749 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10750 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10751 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10752 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10753 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10754 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10755 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10756 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10757 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10758 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10759 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10760 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10761 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10762 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10763 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10764 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10765 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10766 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10767 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10768 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10769 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10770 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10771 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10772 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10773 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10774 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10775 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10776 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10777 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10778 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10779 #   undef JITTER_BRANCH_FAST_IF_AND
10780 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10781 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10782 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10783 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10784 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10785 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10786 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10787 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10788 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10789 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10790 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10791 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10792 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10793 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10794 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10795 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10796 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10797 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10798 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10799 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10800 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
10801 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10802 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
10803 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10804 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
10805 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10806 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
10807 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10808 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
10809     /* This specialized instruction is a caller.
10810        Its 1-th argument, a literal, is the return address where to jump
10811        back after the procedure returns.  Branch-and-link
10812        functionality is enabled for this instruction. */
10813 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
10814 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10815 
10816 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       46
10817 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n8/retR
10818 
10819 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n8__retR
10820 
10821   /* The residual arity for this instruction does not depend on fast labels. */
10822   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
10823 
10824     /* The 0th argument is a nonresidual literal. */
10825 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
10826 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
10827 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
10828 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
10829 #   define JITTER_ARGF0 JITTER_ARGP0
10830 
10831     /* The 1th argument is a residual literal. */
10832 #if defined(JITTER_DISPATCH_NO_THREADING)
10833 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
10834     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
10835 #elif defined (JITTER_REPLICATE)
10836 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
10837 #else
10838 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
10839 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
10840 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
10841 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
10842 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
10843 #   define JITTER_ARGF1 JITTER_ARGP1
10844 
10845 
10846 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10847     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10848   /* We use the implicit atgument at the end of the calling.
10849      instruction to discover the procedure return address. */
10850   const void * _jitter_return_pointer = JITTER_ARGP1;
10851   /* And make it accessible to the user (who will usually call
10852      JITTER_BRANCH_AND_LINK) thru a nice macro. */
10853 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
10854 #endif
10855 
10856 #if defined (JITTER_PROFILE_SAMPLE)
10857   JITTER_PROFILE_SAMPLE_UPDATE
10858      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10859       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10860   /* Force the compiler not move sample-profiling instrumentation
10861      beyond this point; this way the actual user code is timed.
10862      This is still not perfect, as residuals are materialised before
10863      we arrive here, but should be adequate at least for slow VM
10864      instructions. */
10865   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
10866 #endif
10867 #if defined (JITTER_PROFILE_COUNT)
10868   /* Notice that, differently from the code above, this
10869      instrumentation code *can* be reordered freely: as long as a
10870      VM instruction is counted, the count increment can be placed
10871      anyehere.  Let GCC move this code and possibly achieve better
10872      throughput by exploiting instruction-level parallelism and
10873      therefore approximate more closely a non-profiled build. */
10874   JITTER_PROFILE_COUNT_UPDATE
10875      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
10876       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
10877 #endif
10878 
10879 /* User-specified code, instruction-beginning-c part: beginning. */
10880 
10881 
10882 /* User-specified code, instruction-beginning-c part: end */
10883 
10884 
10885     /* User code for call-compiled/n8/retR . */
10886 
10887     const jitter_uint in_arity = JITTER_ARGN0;
10888     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
10889     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
10890 
10891     /* Here we can assume that * c is a compiled closure without checking. */
10892     struct jitterlisp_compiled_closure *cc = & c->compiled;
10893 
10894     /* Make place for the return address in the return stack.  The
10895        actual value will be written by the callee. */
10896     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
10897 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
10898 
10899     /* Branch-and-link to the native code, whose first instruction
10900        will be a prolog. */
10901     JITTER_BRANCH_AND_LINK(cc->first_program_point);
10902 
10903     /* End of the user code for call-compiled/n8/retR . */
10904 
10905 /* User-specified code, instruction-end-c part: beginning. */
10906 
10907 
10908 /* User-specified code, instruction-end-c part: end */
10909 
10910     /* Undefine macros only visible in caller instructions. */
10911 #   undef JITTER_BRANCH_AND_LINK
10912 #   undef JITTER_BRANCH_FAST_AND_LINK
10913 
10914     /* Undefine the call-compiled/n8/retR argument macros so they can't be used
10915        by mistake in the instruction body coming next. */
10916 #   undef JITTER_SLOW_REGISTER_OFFSET0
10917 #   undef JITTER_ARG0
10918 #   undef JITTER_ARGN0
10919 #   undef JITTER_ARGU0
10920 #   undef JITTER_ARGP0
10921 #   undef JITTER_ARGF0
10922 #   undef JITTER_SLOW_REGISTER_OFFSET1
10923 #   undef JITTER_ARG1
10924 #   undef JITTER_ARGN1
10925 #   undef JITTER_ARGU1
10926 #   undef JITTER_ARGP1
10927 #   undef JITTER_ARGF1
10928 
10929 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
10930 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
10931 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
10932 
10933   }
10934 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
10935     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
10936 # undef JITTER_RETURN_ADDRESS
10937 #endif
10938 
10939  JITTER_INSTRUCTION_EPILOG_(call-compiled/n8/retR, call_mcompiled__n8__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
10940 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
10941 
10942   JITTER_INSTRUCTION_PROLOG_(call-compiled/n9/retR, call_mcompiled__n9__retR, hot)
10943   {
10944     /* This specialized instruction is not a replacement. */
10945 #   undef JITTER_BRANCH_FAST
10946 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
10947 #   undef JITTER_BRANCH_FAST_IF_ZERO
10948 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
10949 #   undef JITTER_BRANCH_FAST_IF_NONZERO
10950 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
10951 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
10952 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
10953 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
10954 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
10955 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
10956 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
10957 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
10958 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
10959 #   undef JITTER_BRANCH_FAST_IF_EQUAL
10960 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
10961 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
10962 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
10963 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
10964 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
10965 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10966 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
10967 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10968 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
10969 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10970 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
10971 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10972 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
10973 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10974 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
10975 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10976 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
10977 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10978 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
10979 #   undef JITTER_BRANCH_FAST_IF_AND
10980 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
10981 #   undef JITTER_BRANCH_FAST_IF_NOTAND
10982 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
10983 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10984 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
10985 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10986 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
10987 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10988 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
10989 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10990 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
10991 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10992 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
10993 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10994 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
10995 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10996 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
10997 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10998 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
10999 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11000 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11001 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11002 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11003 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11004 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11005 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11006 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11007 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11008 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11009     /* This specialized instruction is a caller.
11010        Its 1-th argument, a literal, is the return address where to jump
11011        back after the procedure returns.  Branch-and-link
11012        functionality is enabled for this instruction. */
11013 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
11014 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11015 
11016 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       47
11017 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n9/retR
11018 
11019 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n9__retR
11020 
11021   /* The residual arity for this instruction does not depend on fast labels. */
11022   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
11023 
11024     /* The 0th argument is a nonresidual literal. */
11025 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
11026 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
11027 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
11028 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
11029 #   define JITTER_ARGF0 JITTER_ARGP0
11030 
11031     /* The 1th argument is a residual literal. */
11032 #if defined(JITTER_DISPATCH_NO_THREADING)
11033 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
11034     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
11035 #elif defined (JITTER_REPLICATE)
11036 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
11037 #else
11038 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
11039 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
11040 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
11041 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
11042 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
11043 #   define JITTER_ARGF1 JITTER_ARGP1
11044 
11045 
11046 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11047     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11048   /* We use the implicit atgument at the end of the calling.
11049      instruction to discover the procedure return address. */
11050   const void * _jitter_return_pointer = JITTER_ARGP1;
11051   /* And make it accessible to the user (who will usually call
11052      JITTER_BRANCH_AND_LINK) thru a nice macro. */
11053 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
11054 #endif
11055 
11056 #if defined (JITTER_PROFILE_SAMPLE)
11057   JITTER_PROFILE_SAMPLE_UPDATE
11058      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11059       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11060   /* Force the compiler not move sample-profiling instrumentation
11061      beyond this point; this way the actual user code is timed.
11062      This is still not perfect, as residuals are materialised before
11063      we arrive here, but should be adequate at least for slow VM
11064      instructions. */
11065   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11066 #endif
11067 #if defined (JITTER_PROFILE_COUNT)
11068   /* Notice that, differently from the code above, this
11069      instrumentation code *can* be reordered freely: as long as a
11070      VM instruction is counted, the count increment can be placed
11071      anyehere.  Let GCC move this code and possibly achieve better
11072      throughput by exploiting instruction-level parallelism and
11073      therefore approximate more closely a non-profiled build. */
11074   JITTER_PROFILE_COUNT_UPDATE
11075      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11076       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11077 #endif
11078 
11079 /* User-specified code, instruction-beginning-c part: beginning. */
11080 
11081 
11082 /* User-specified code, instruction-beginning-c part: end */
11083 
11084 
11085     /* User code for call-compiled/n9/retR . */
11086 
11087     const jitter_uint in_arity = JITTER_ARGN0;
11088     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
11089     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
11090 
11091     /* Here we can assume that * c is a compiled closure without checking. */
11092     struct jitterlisp_compiled_closure *cc = & c->compiled;
11093 
11094     /* Make place for the return address in the return stack.  The
11095        actual value will be written by the callee. */
11096     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
11097 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
11098 
11099     /* Branch-and-link to the native code, whose first instruction
11100        will be a prolog. */
11101     JITTER_BRANCH_AND_LINK(cc->first_program_point);
11102 
11103     /* End of the user code for call-compiled/n9/retR . */
11104 
11105 /* User-specified code, instruction-end-c part: beginning. */
11106 
11107 
11108 /* User-specified code, instruction-end-c part: end */
11109 
11110     /* Undefine macros only visible in caller instructions. */
11111 #   undef JITTER_BRANCH_AND_LINK
11112 #   undef JITTER_BRANCH_FAST_AND_LINK
11113 
11114     /* Undefine the call-compiled/n9/retR argument macros so they can't be used
11115        by mistake in the instruction body coming next. */
11116 #   undef JITTER_SLOW_REGISTER_OFFSET0
11117 #   undef JITTER_ARG0
11118 #   undef JITTER_ARGN0
11119 #   undef JITTER_ARGU0
11120 #   undef JITTER_ARGP0
11121 #   undef JITTER_ARGF0
11122 #   undef JITTER_SLOW_REGISTER_OFFSET1
11123 #   undef JITTER_ARG1
11124 #   undef JITTER_ARGN1
11125 #   undef JITTER_ARGU1
11126 #   undef JITTER_ARGP1
11127 #   undef JITTER_ARGF1
11128 
11129 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11130 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11131 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11132 
11133   }
11134 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11135     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11136 # undef JITTER_RETURN_ADDRESS
11137 #endif
11138 
11139  JITTER_INSTRUCTION_EPILOG_(call-compiled/n9/retR, call_mcompiled__n9__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11140 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11141 
11142   JITTER_INSTRUCTION_PROLOG_(call-compiled/n10/retR, call_mcompiled__n10__retR, hot)
11143   {
11144     /* This specialized instruction is not a replacement. */
11145 #   undef JITTER_BRANCH_FAST
11146 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11147 #   undef JITTER_BRANCH_FAST_IF_ZERO
11148 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11149 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11150 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11151 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11152 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11153 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11154 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11155 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11156 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11157 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11158 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11159 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11160 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11161 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11162 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11163 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11164 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11165 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11166 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11167 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11168 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11169 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11170 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11171 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11172 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11173 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11174 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11175 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11176 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11177 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11178 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11179 #   undef JITTER_BRANCH_FAST_IF_AND
11180 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11181 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11182 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11183 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11184 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11185 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11186 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11187 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11188 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11189 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11190 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11191 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11192 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11193 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11194 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11195 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11196 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11197 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11198 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11199 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11200 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11201 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11202 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11203 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11204 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11205 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11206 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11207 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11208 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11209     /* This specialized instruction is a caller.
11210        Its 1-th argument, a literal, is the return address where to jump
11211        back after the procedure returns.  Branch-and-link
11212        functionality is enabled for this instruction. */
11213 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
11214 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11215 
11216 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       48
11217 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/n10/retR
11218 
11219 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__n10__retR
11220 
11221   /* The residual arity for this instruction does not depend on fast labels. */
11222   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
11223 
11224     /* The 0th argument is a nonresidual literal. */
11225 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
11226 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
11227 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
11228 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
11229 #   define JITTER_ARGF0 JITTER_ARGP0
11230 
11231     /* The 1th argument is a residual literal. */
11232 #if defined(JITTER_DISPATCH_NO_THREADING)
11233 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
11234     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
11235 #elif defined (JITTER_REPLICATE)
11236 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
11237 #else
11238 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
11239 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
11240 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
11241 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
11242 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
11243 #   define JITTER_ARGF1 JITTER_ARGP1
11244 
11245 
11246 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11247     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11248   /* We use the implicit atgument at the end of the calling.
11249      instruction to discover the procedure return address. */
11250   const void * _jitter_return_pointer = JITTER_ARGP1;
11251   /* And make it accessible to the user (who will usually call
11252      JITTER_BRANCH_AND_LINK) thru a nice macro. */
11253 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
11254 #endif
11255 
11256 #if defined (JITTER_PROFILE_SAMPLE)
11257   JITTER_PROFILE_SAMPLE_UPDATE
11258      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11259       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11260   /* Force the compiler not move sample-profiling instrumentation
11261      beyond this point; this way the actual user code is timed.
11262      This is still not perfect, as residuals are materialised before
11263      we arrive here, but should be adequate at least for slow VM
11264      instructions. */
11265   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11266 #endif
11267 #if defined (JITTER_PROFILE_COUNT)
11268   /* Notice that, differently from the code above, this
11269      instrumentation code *can* be reordered freely: as long as a
11270      VM instruction is counted, the count increment can be placed
11271      anyehere.  Let GCC move this code and possibly achieve better
11272      throughput by exploiting instruction-level parallelism and
11273      therefore approximate more closely a non-profiled build. */
11274   JITTER_PROFILE_COUNT_UPDATE
11275      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11276       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11277 #endif
11278 
11279 /* User-specified code, instruction-beginning-c part: beginning. */
11280 
11281 
11282 /* User-specified code, instruction-beginning-c part: end */
11283 
11284 
11285     /* User code for call-compiled/n10/retR . */
11286 
11287     const jitter_uint in_arity = JITTER_ARGN0;
11288     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
11289     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
11290 
11291     /* Here we can assume that * c is a compiled closure without checking. */
11292     struct jitterlisp_compiled_closure *cc = & c->compiled;
11293 
11294     /* Make place for the return address in the return stack.  The
11295        actual value will be written by the callee. */
11296     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
11297 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
11298 
11299     /* Branch-and-link to the native code, whose first instruction
11300        will be a prolog. */
11301     JITTER_BRANCH_AND_LINK(cc->first_program_point);
11302 
11303     /* End of the user code for call-compiled/n10/retR . */
11304 
11305 /* User-specified code, instruction-end-c part: beginning. */
11306 
11307 
11308 /* User-specified code, instruction-end-c part: end */
11309 
11310     /* Undefine macros only visible in caller instructions. */
11311 #   undef JITTER_BRANCH_AND_LINK
11312 #   undef JITTER_BRANCH_FAST_AND_LINK
11313 
11314     /* Undefine the call-compiled/n10/retR argument macros so they can't be used
11315        by mistake in the instruction body coming next. */
11316 #   undef JITTER_SLOW_REGISTER_OFFSET0
11317 #   undef JITTER_ARG0
11318 #   undef JITTER_ARGN0
11319 #   undef JITTER_ARGU0
11320 #   undef JITTER_ARGP0
11321 #   undef JITTER_ARGF0
11322 #   undef JITTER_SLOW_REGISTER_OFFSET1
11323 #   undef JITTER_ARG1
11324 #   undef JITTER_ARGN1
11325 #   undef JITTER_ARGU1
11326 #   undef JITTER_ARGP1
11327 #   undef JITTER_ARGF1
11328 
11329 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11330 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11331 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11332 
11333   }
11334 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11335     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11336 # undef JITTER_RETURN_ADDRESS
11337 #endif
11338 
11339  JITTER_INSTRUCTION_EPILOG_(call-compiled/n10/retR, call_mcompiled__n10__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11340 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11341 
11342   JITTER_INSTRUCTION_PROLOG_(call-compiled/nR/retR, call_mcompiled__nR__retR, cold)
11343   {
11344     /* This specialized instruction is not a replacement. */
11345 #   undef JITTER_BRANCH_FAST
11346 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11347 #   undef JITTER_BRANCH_FAST_IF_ZERO
11348 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11349 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11350 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11351 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11352 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11353 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11354 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11355 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11356 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11357 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11358 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11359 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11360 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11361 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11362 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11363 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11364 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11365 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11366 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11367 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11368 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11369 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11370 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11371 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11372 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11373 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11374 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11375 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11376 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11377 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11378 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11379 #   undef JITTER_BRANCH_FAST_IF_AND
11380 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11381 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11382 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11383 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11384 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11385 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11386 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11387 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11388 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11389 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11390 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11391 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11392 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11393 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11394 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11395 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11396 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11397 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11398 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11399 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11400 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11401 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11402 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11403 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11404 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11405 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11406 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11407 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11408 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11409     /* This specialized instruction is a caller.
11410        Its 1-th argument, a literal, is the return address where to jump
11411        back after the procedure returns.  Branch-and-link
11412        functionality is enabled for this instruction. */
11413 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
11414 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11415 
11416 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       49
11417 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-compiled/nR/retR
11418 
11419 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mcompiled__nR__retR
11420 
11421   /* The residual arity for this instruction does not depend on fast labels. */
11422   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
11423 
11424     /* The 0th argument is a residual literal. */
11425 #if defined(JITTER_DISPATCH_NO_THREADING)
11426 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
11427     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
11428 #elif defined (JITTER_REPLICATE)
11429 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
11430 #else
11431 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
11432 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
11433 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
11434 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
11435 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
11436 #   define JITTER_ARGF0 JITTER_ARGP0
11437 
11438     /* The 1th argument is a residual literal. */
11439 #if defined(JITTER_DISPATCH_NO_THREADING)
11440 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
11441     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
11442 #elif defined (JITTER_REPLICATE)
11443 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
11444 #else
11445 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
11446 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
11447 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
11448 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
11449 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
11450 #   define JITTER_ARGF1 JITTER_ARGP1
11451 
11452 
11453 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11454     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11455   /* We use the implicit atgument at the end of the calling.
11456      instruction to discover the procedure return address. */
11457   const void * _jitter_return_pointer = JITTER_ARGP1;
11458   /* And make it accessible to the user (who will usually call
11459      JITTER_BRANCH_AND_LINK) thru a nice macro. */
11460 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
11461 #endif
11462 
11463 #if defined (JITTER_PROFILE_SAMPLE)
11464   JITTER_PROFILE_SAMPLE_UPDATE
11465      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11466       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11467   /* Force the compiler not move sample-profiling instrumentation
11468      beyond this point; this way the actual user code is timed.
11469      This is still not perfect, as residuals are materialised before
11470      we arrive here, but should be adequate at least for slow VM
11471      instructions. */
11472   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11473 #endif
11474 #if defined (JITTER_PROFILE_COUNT)
11475   /* Notice that, differently from the code above, this
11476      instrumentation code *can* be reordered freely: as long as a
11477      VM instruction is counted, the count increment can be placed
11478      anyehere.  Let GCC move this code and possibly achieve better
11479      throughput by exploiting instruction-level parallelism and
11480      therefore approximate more closely a non-profiled build. */
11481   JITTER_PROFILE_COUNT_UPDATE
11482      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11483       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11484 #endif
11485 
11486 /* User-specified code, instruction-beginning-c part: beginning. */
11487 
11488 
11489 /* User-specified code, instruction-beginning-c part: end */
11490 
11491 
11492     /* User code for call-compiled/nR/retR . */
11493 
11494     const jitter_uint in_arity = JITTER_ARGN0;
11495     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
11496     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
11497 
11498     /* Here we can assume that * c is a compiled closure without checking. */
11499     struct jitterlisp_compiled_closure *cc = & c->compiled;
11500 
11501     /* Make place for the return address in the return stack.  The
11502        actual value will be written by the callee. */
11503     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
11504 //    JITTER_TOP_RETURNSTACK() = 0x4242aaaa; // FIXME: just a test.  Remove.
11505 
11506     /* Branch-and-link to the native code, whose first instruction
11507        will be a prolog. */
11508     JITTER_BRANCH_AND_LINK(cc->first_program_point);
11509 
11510     /* End of the user code for call-compiled/nR/retR . */
11511 
11512 /* User-specified code, instruction-end-c part: beginning. */
11513 
11514 
11515 /* User-specified code, instruction-end-c part: end */
11516 
11517     /* Undefine macros only visible in caller instructions. */
11518 #   undef JITTER_BRANCH_AND_LINK
11519 #   undef JITTER_BRANCH_FAST_AND_LINK
11520 
11521     /* Undefine the call-compiled/nR/retR argument macros so they can't be used
11522        by mistake in the instruction body coming next. */
11523 #   undef JITTER_SLOW_REGISTER_OFFSET0
11524 #   undef JITTER_ARG0
11525 #   undef JITTER_ARGN0
11526 #   undef JITTER_ARGU0
11527 #   undef JITTER_ARGP0
11528 #   undef JITTER_ARGF0
11529 #   undef JITTER_SLOW_REGISTER_OFFSET1
11530 #   undef JITTER_ARG1
11531 #   undef JITTER_ARGN1
11532 #   undef JITTER_ARGU1
11533 #   undef JITTER_ARGP1
11534 #   undef JITTER_ARGF1
11535 
11536 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11537 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11538 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11539 
11540   }
11541 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11542     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11543 # undef JITTER_RETURN_ADDRESS
11544 #endif
11545 
11546  JITTER_INSTRUCTION_EPILOG_(call-compiled/nR/retR, call_mcompiled__nR__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11547 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11548 
11549   JITTER_INSTRUCTION_PROLOG_(call-from-c/retR, call_mfrom_mc__retR, hot)
11550   {
11551     /* This specialized instruction is not a replacement. */
11552 #   undef JITTER_BRANCH_FAST
11553 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11554 #   undef JITTER_BRANCH_FAST_IF_ZERO
11555 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11556 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11557 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11558 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11559 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11560 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11561 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11562 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11563 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11564 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11565 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11566 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11567 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11568 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11569 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11570 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11571 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11572 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11573 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11574 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11575 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11576 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11577 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11578 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11579 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11580 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11581 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11582 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11583 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11584 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11585 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11586 #   undef JITTER_BRANCH_FAST_IF_AND
11587 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11588 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11589 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11590 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11591 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11592 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11593 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11594 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11595 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11596 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11597 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11598 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11599 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11600 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11601 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11602 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11603 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11604 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11605 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11606 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11607 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11608 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11609 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11610 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11611 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11612 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11613 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11614 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11615 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11616     /* This specialized instruction is a caller.
11617        Its 0-th argument, a literal, is the return address where to jump
11618        back after the procedure returns.  Branch-and-link
11619        functionality is enabled for this instruction. */
11620 #   define JITTER_BRANCH_AND_LINK      JITTER_BRANCH_AND_LINK_INTERNAL
11621 #   define JITTER_BRANCH_FAST_AND_LINK JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11622 
11623 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       50
11624 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         call-from-c/retR
11625 
11626 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME call_mfrom_mc__retR
11627 
11628   /* The residual arity for this instruction does not depend on fast labels. */
11629   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
11630 
11631     /* The 0th argument is a residual literal. */
11632 #if defined(JITTER_DISPATCH_NO_THREADING)
11633 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
11634     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
11635 #elif defined (JITTER_REPLICATE)
11636 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
11637 #else
11638 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
11639 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
11640 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
11641 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
11642 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
11643 #   define JITTER_ARGF0 JITTER_ARGP0
11644 
11645 
11646 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11647     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11648   /* We use the implicit atgument at the end of the calling.
11649      instruction to discover the procedure return address. */
11650   const void * _jitter_return_pointer = JITTER_ARGP0;
11651   /* And make it accessible to the user (who will usually call
11652      JITTER_BRANCH_AND_LINK) thru a nice macro. */
11653 # define JITTER_RETURN_ADDRESS _jitter_return_pointer
11654 #endif
11655 
11656 #if defined (JITTER_PROFILE_SAMPLE)
11657   JITTER_PROFILE_SAMPLE_UPDATE
11658      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11659       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11660   /* Force the compiler not move sample-profiling instrumentation
11661      beyond this point; this way the actual user code is timed.
11662      This is still not perfect, as residuals are materialised before
11663      we arrive here, but should be adequate at least for slow VM
11664      instructions. */
11665   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11666 #endif
11667 #if defined (JITTER_PROFILE_COUNT)
11668   /* Notice that, differently from the code above, this
11669      instrumentation code *can* be reordered freely: as long as a
11670      VM instruction is counted, the count increment can be placed
11671      anyehere.  Let GCC move this code and possibly achieve better
11672      throughput by exploiting instruction-level parallelism and
11673      therefore approximate more closely a non-profiled build. */
11674   JITTER_PROFILE_COUNT_UPDATE
11675      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11676       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11677 #endif
11678 
11679 /* User-specified code, instruction-beginning-c part: beginning. */
11680 
11681 
11682 /* User-specified code, instruction-beginning-c part: end */
11683 
11684 
11685     /* User code for call-from-c/retR . */
11686 
11687     /* Pop a number (untagged) off the stack, so that I know at which
11688        depth to find the closure.  The arity check must have been
11689        performed already on the interpreter side. */
11690     const jitter_uint in_arity_plus_one = JITTER_TOP_MAINSTACK();
11691 
11692     /* What follows is similar to the call instruction in the case of a compiled
11693        callee.  Shall I factor the common code with a macro? */
11694 
11695     /* Decode the closure. */
11696 //#define STRESS
11697 #ifndef STRESS
11698     // FIXME: This is correct, and faster ...
11699     jitterlisp_object callee
11700       = JITTER_AT_NONZERO_DEPTH_MAINSTACK(in_arity_plus_one);
11701     JITTER_DROP_MAINSTACK();
11702 #else
11703     // FIXME ...But this stresses the code better (mips gcc 8, x86_64 gcc 7).
11704     JITTER_DROP_MAINSTACK();
11705     jitterlisp_object callee
11706       = JITTER_AT_DEPTH_MAINSTACK(in_arity_plus_one - 1);
11707 #endif // #ifndef STRESS
11708     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
11709     struct jitterlisp_compiled_closure *cc = & c->compiled;
11710 
11711     /* Make place for the return address in the return stack.  The
11712        actual value will be written by the callee. */
11713     JITTER_PUSH_UNSPECIFIED_RETURNSTACK();
11714 
11715     /* Branch-and-link.  This follows the ordinary calling convention,
11716        with the main stack containing the closure and its actuals, known
11717        to be in the correct number.  The next VM instruction will be a
11718        prolog saving the link; then execution will fall thru into the
11719        compiled closure body. */
11720     JITTER_BRANCH_AND_LINK(cc->first_program_point);
11721 
11722     /* End of the user code for call-from-c/retR . */
11723 
11724 /* User-specified code, instruction-end-c part: beginning. */
11725 
11726 
11727 /* User-specified code, instruction-end-c part: end */
11728 
11729     /* Undefine macros only visible in caller instructions. */
11730 #   undef JITTER_BRANCH_AND_LINK
11731 #   undef JITTER_BRANCH_FAST_AND_LINK
11732 
11733     /* Undefine the call-from-c/retR argument macros so they can't be used
11734        by mistake in the instruction body coming next. */
11735 #   undef JITTER_SLOW_REGISTER_OFFSET0
11736 #   undef JITTER_ARG0
11737 #   undef JITTER_ARGN0
11738 #   undef JITTER_ARGU0
11739 #   undef JITTER_ARGP0
11740 #   undef JITTER_ARGF0
11741 
11742 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11743 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11744 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11745 
11746   }
11747 #if    defined(JITTER_DISPATCH_NO_THREADING)         \
11748     && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE)
11749 # undef JITTER_RETURN_ADDRESS
11750 #endif
11751 
11752  JITTER_INSTRUCTION_EPILOG_(call-from-c/retR, call_mfrom_mc__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11753 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11754 
11755   JITTER_INSTRUCTION_PROLOG_(canonicalize-boolean, canonicalize_mboolean, hot)
11756   {
11757     /* This specialized instruction is not a replacement. */
11758 #   undef JITTER_BRANCH_FAST
11759 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11760 #   undef JITTER_BRANCH_FAST_IF_ZERO
11761 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11762 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11763 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11764 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11765 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11766 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11767 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11768 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11769 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11770 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11771 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11772 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11773 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11774 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11775 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11776 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11777 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11778 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11779 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11780 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11781 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11782 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11783 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11784 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11785 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11786 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11787 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11788 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11789 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11790 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11791 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11792 #   undef JITTER_BRANCH_FAST_IF_AND
11793 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11794 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11795 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11796 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11797 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11798 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11799 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11800 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11801 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11802 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11803 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11804 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11805 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11806 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11807 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11808 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11809 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11810 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11811 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11812 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11813 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11814 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11815 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11816 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11817 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11818 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11819 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11820 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11821 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11822 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       51
11823 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         canonicalize-boolean
11824 
11825 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME canonicalize_mboolean
11826 
11827   /* The residual arity for this instruction does not depend on fast labels. */
11828   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11829 
11830 
11831 #if defined (JITTER_PROFILE_SAMPLE)
11832   JITTER_PROFILE_SAMPLE_UPDATE
11833      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11834       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11835   /* Force the compiler not move sample-profiling instrumentation
11836      beyond this point; this way the actual user code is timed.
11837      This is still not perfect, as residuals are materialised before
11838      we arrive here, but should be adequate at least for slow VM
11839      instructions. */
11840   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
11841 #endif
11842 #if defined (JITTER_PROFILE_COUNT)
11843   /* Notice that, differently from the code above, this
11844      instrumentation code *can* be reordered freely: as long as a
11845      VM instruction is counted, the count increment can be placed
11846      anyehere.  Let GCC move this code and possibly achieve better
11847      throughput by exploiting instruction-level parallelism and
11848      therefore approximate more closely a non-profiled build. */
11849   JITTER_PROFILE_COUNT_UPDATE
11850      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11851       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11852 #endif
11853 
11854 /* User-specified code, instruction-beginning-c part: beginning. */
11855 
11856 
11857 /* User-specified code, instruction-beginning-c part: end */
11858 
11859 
11860     /* User code for canonicalize-boolean . */
11861 
11862     JITTERLISP_BOOLEAN_CANONICALIZE_(JITTER_TOP_MAINSTACK(),
11863                                      JITTER_TOP_MAINSTACK());
11864 
11865     /* End of the user code for canonicalize-boolean . */
11866 
11867 /* User-specified code, instruction-end-c part: beginning. */
11868 
11869 
11870 /* User-specified code, instruction-end-c part: end */
11871 
11872     /* Undefine the canonicalize-boolean argument macros so they can't be used
11873        by mistake in the instruction body coming next. */
11874 
11875 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
11876 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
11877 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
11878 
11879   }
11880  JITTER_INSTRUCTION_EPILOG_(canonicalize-boolean, canonicalize_mboolean, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
11881 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
11882 
11883   JITTER_INSTRUCTION_PROLOG_(check-closure/fR, check_mclosure__fR, hot)
11884   {
11885     /* This specialized instruction is not a replacement. */
11886 #   undef JITTER_BRANCH_FAST
11887 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
11888 #   undef JITTER_BRANCH_FAST_IF_ZERO
11889 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
11890 #   undef JITTER_BRANCH_FAST_IF_NONZERO
11891 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
11892 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
11893 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
11894 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
11895 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
11896 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
11897 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
11898 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
11899 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
11900 #   undef JITTER_BRANCH_FAST_IF_EQUAL
11901 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
11902 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
11903 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
11904 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
11905 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
11906 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11907 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
11908 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11909 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
11910 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11911 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
11912 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11913 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
11914 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11915 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
11916 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11917 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
11918 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11919 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
11920 #   undef JITTER_BRANCH_FAST_IF_AND
11921 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
11922 #   undef JITTER_BRANCH_FAST_IF_NOTAND
11923 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
11924 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11925 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
11926 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11927 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
11928 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11929 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
11930 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11931 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
11932 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11933 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
11934 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11935 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
11936 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11937 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
11938 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11939 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
11940 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11941 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
11942 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11943 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
11944 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11945 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
11946 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11947 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
11948 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11949 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
11950 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       52
11951 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-closure/fR
11952 
11953 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_mclosure__fR
11954 
11955   /* The residual arity varies depending on whether we have fast labels. */
11956 #ifdef JITTER_HAVE_PATCH_IN
11957   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
11958 #else
11959   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
11960 #endif // #ifdef JITTER_HAVE_PATCH_IN
11961 
11962   /* Define argument-access macros for check-closure/fR . */
11963 #ifdef JITTER_HAVE_PATCH_IN
11964   /* Define argument-access macros assuming that fast branches are enabled. */
11965     /* The 0th argument is a "residual" fast label.  Define its
11966        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
11967        so that at replication time we know what instruction address to patch in. */
11968 #   define JITTER_ARGF0 0
11969     /* JITTER_ARG0 is intentionally not defined for a fast label. */
11970 
11971 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
11972 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
11973 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
11974 
11975 #else
11976   /* Define argument-access macros assuming that fast branches are disabled. */
11977 #if defined(JITTER_DISPATCH_NO_THREADING)
11978 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
11979     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
11980 #elif defined (JITTER_REPLICATE)
11981 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
11982 #else
11983 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
11984 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
11985 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
11986 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
11987 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
11988 #   define JITTER_ARGF0 JITTER_ARGP0
11989 
11990 # endif // #ifdef JITTER_HAVE_PATCH_IN
11991 
11992 #if defined (JITTER_PROFILE_SAMPLE)
11993   JITTER_PROFILE_SAMPLE_UPDATE
11994      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
11995       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
11996   /* Force the compiler not move sample-profiling instrumentation
11997      beyond this point; this way the actual user code is timed.
11998      This is still not perfect, as residuals are materialised before
11999      we arrive here, but should be adequate at least for slow VM
12000      instructions. */
12001   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12002 #endif
12003 #if defined (JITTER_PROFILE_COUNT)
12004   /* Notice that, differently from the code above, this
12005      instrumentation code *can* be reordered freely: as long as a
12006      VM instruction is counted, the count increment can be placed
12007      anyehere.  Let GCC move this code and possibly achieve better
12008      throughput by exploiting instruction-level parallelism and
12009      therefore approximate more closely a non-profiled build. */
12010   JITTER_PROFILE_COUNT_UPDATE
12011      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12012       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12013 #endif
12014 
12015 /* User-specified code, instruction-beginning-c part: beginning. */
12016 
12017 
12018 /* User-specified code, instruction-beginning-c part: end */
12019 
12020 
12021     /* User code for check-closure/fR . */
12022 
12023 #   ifndef JITTERLISP_UNSAFE
12024       jitterlisp_object top = JITTER_TOP_MAINSTACK();
12025       if (! JITTERLISP_IS_CLOSURE(top))
12026         JITTER_BRANCH_FAST(JITTER_ARGF0);
12027 #   endif // #ifndef JITTERLISP_UNSAFE
12028 
12029     /* End of the user code for check-closure/fR . */
12030 
12031 /* User-specified code, instruction-end-c part: beginning. */
12032 
12033 
12034 /* User-specified code, instruction-end-c part: end */
12035 
12036     /* Undefine the check-closure/fR argument macros so they can't be used
12037        by mistake in the instruction body coming next. */
12038 #   undef JITTER_SLOW_REGISTER_OFFSET0
12039 #   undef JITTER_ARG0
12040 #   undef JITTER_ARGN0
12041 #   undef JITTER_ARGU0
12042 #   undef JITTER_ARGP0
12043 #   undef JITTER_ARGF0
12044 
12045 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12046 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12047 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12048 
12049   }
12050  JITTER_INSTRUCTION_EPILOG_(check-closure/fR, check_mclosure__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12051 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12052 
12053   JITTER_INSTRUCTION_PROLOG_(check-global-defined/nR/fR, check_mglobal_mdefined__nR__fR, cold)
12054   {
12055     /* This specialized instruction is not a replacement. */
12056 #   undef JITTER_BRANCH_FAST
12057 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12058 #   undef JITTER_BRANCH_FAST_IF_ZERO
12059 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12060 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12061 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12062 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12063 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12064 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12065 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12066 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12067 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12068 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12069 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12070 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12071 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12072 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12073 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12074 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12075 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12076 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12077 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12078 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12079 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12080 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12081 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12082 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12083 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12084 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12085 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12086 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12087 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12088 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12089 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12090 #   undef JITTER_BRANCH_FAST_IF_AND
12091 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12092 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12093 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12094 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12095 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12096 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12097 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12098 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12099 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12100 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12101 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12102 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12103 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12104 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12105 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12106 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12107 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12108 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12109 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12110 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12111 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12112 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12113 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12114 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12115 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12116 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12117 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12118 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12119 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12120 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       53
12121 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-global-defined/nR/fR
12122 
12123 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_mglobal_mdefined__nR__fR
12124 
12125   /* The residual arity varies depending on whether we have fast labels. */
12126 #ifdef JITTER_HAVE_PATCH_IN
12127   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
12128 #else
12129   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
12130 #endif // #ifdef JITTER_HAVE_PATCH_IN
12131 
12132   /* Define argument-access macros for check-global-defined/nR/fR . */
12133 #ifdef JITTER_HAVE_PATCH_IN
12134   /* Define argument-access macros assuming that fast branches are enabled. */
12135     /* The 0th argument is a residual literal. */
12136 #if defined(JITTER_DISPATCH_NO_THREADING)
12137 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
12138     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
12139 #elif defined (JITTER_REPLICATE)
12140 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
12141 #else
12142 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
12143 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
12144 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12145 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12146 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12147 
12148     /* The 1th argument is a "residual" fast label.  Define its
12149        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
12150        so that at replication time we know what instruction address to patch in. */
12151 #   define JITTER_ARGF1 0
12152     /* JITTER_ARG1 is intentionally not defined for a fast label. */
12153 
12154 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12155 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12156 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12157 
12158 #else
12159   /* Define argument-access macros assuming that fast branches are disabled. */
12160     /* The 0th argument is a residual literal. */
12161 #if defined(JITTER_DISPATCH_NO_THREADING)
12162 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
12163     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
12164 #elif defined (JITTER_REPLICATE)
12165 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
12166 #else
12167 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
12168 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
12169 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12170 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12171 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12172 #   define JITTER_ARGF0 JITTER_ARGP0
12173 
12174 #if defined(JITTER_DISPATCH_NO_THREADING)
12175 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
12176     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
12177 #elif defined (JITTER_REPLICATE)
12178 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
12179 #else
12180 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
12181 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
12182 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12183 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12184 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12185 #   define JITTER_ARGF1 JITTER_ARGP1
12186 
12187 # endif // #ifdef JITTER_HAVE_PATCH_IN
12188 
12189 #if defined (JITTER_PROFILE_SAMPLE)
12190   JITTER_PROFILE_SAMPLE_UPDATE
12191      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12192       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12193   /* Force the compiler not move sample-profiling instrumentation
12194      beyond this point; this way the actual user code is timed.
12195      This is still not perfect, as residuals are materialised before
12196      we arrive here, but should be adequate at least for slow VM
12197      instructions. */
12198   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12199 #endif
12200 #if defined (JITTER_PROFILE_COUNT)
12201   /* Notice that, differently from the code above, this
12202      instrumentation code *can* be reordered freely: as long as a
12203      VM instruction is counted, the count increment can be placed
12204      anyehere.  Let GCC move this code and possibly achieve better
12205      throughput by exploiting instruction-level parallelism and
12206      therefore approximate more closely a non-profiled build. */
12207   JITTER_PROFILE_COUNT_UPDATE
12208      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12209       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12210 #endif
12211 
12212 /* User-specified code, instruction-beginning-c part: beginning. */
12213 
12214 
12215 /* User-specified code, instruction-beginning-c part: end */
12216 
12217 
12218     /* User code for check-global-defined/nR/fR . */
12219 
12220 #ifndef JITTERLISP_UNSAFE
12221     jitterlisp_object tagged_symbol = JITTER_ARGN0;
12222     struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
12223     JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
12224                                  JITTER_ARGF1);
12225 #endif // #ifndef JITTERLISP_UNSAFE
12226 
12227     /* End of the user code for check-global-defined/nR/fR . */
12228 
12229 /* User-specified code, instruction-end-c part: beginning. */
12230 
12231 
12232 /* User-specified code, instruction-end-c part: end */
12233 
12234     /* Undefine the check-global-defined/nR/fR argument macros so they can't be used
12235        by mistake in the instruction body coming next. */
12236 #   undef JITTER_SLOW_REGISTER_OFFSET0
12237 #   undef JITTER_ARG0
12238 #   undef JITTER_ARGN0
12239 #   undef JITTER_ARGU0
12240 #   undef JITTER_ARGP0
12241 #   undef JITTER_ARGF0
12242 #   undef JITTER_SLOW_REGISTER_OFFSET1
12243 #   undef JITTER_ARG1
12244 #   undef JITTER_ARGN1
12245 #   undef JITTER_ARGU1
12246 #   undef JITTER_ARGP1
12247 #   undef JITTER_ARGF1
12248 
12249 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12250 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12251 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12252 
12253   }
12254  JITTER_INSTRUCTION_EPILOG_(check-global-defined/nR/fR, check_mglobal_mdefined__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12255 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12256 
12257   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n0/fR, check_min_marity__n0__fR, hot)
12258   {
12259     /* This specialized instruction is not a replacement. */
12260 #   undef JITTER_BRANCH_FAST
12261 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12262 #   undef JITTER_BRANCH_FAST_IF_ZERO
12263 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12264 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12265 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12266 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12267 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12268 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12269 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12270 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12271 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12272 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12273 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12274 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12275 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12276 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12277 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12278 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12279 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12280 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12281 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12282 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12283 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12284 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12285 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12286 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12287 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12288 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12289 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12290 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12291 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12292 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12293 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12294 #   undef JITTER_BRANCH_FAST_IF_AND
12295 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12296 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12297 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12298 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12299 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12300 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12301 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12302 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12303 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12304 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12305 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12306 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12307 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12308 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12309 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12310 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12311 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12312 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12313 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12314 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12315 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12316 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12317 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12318 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12319 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12320 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12321 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12322 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12323 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12324 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       54
12325 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n0/fR
12326 
12327 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n0__fR
12328 
12329   /* The residual arity varies depending on whether we have fast labels. */
12330 #ifdef JITTER_HAVE_PATCH_IN
12331   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12332 #else
12333   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
12334 #endif // #ifdef JITTER_HAVE_PATCH_IN
12335 
12336   /* Define argument-access macros for check-in-arity/n0/fR . */
12337 #ifdef JITTER_HAVE_PATCH_IN
12338   /* Define argument-access macros assuming that fast branches are enabled. */
12339     /* The 0th argument is a nonresidual literal. */
12340 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
12341 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12342 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12343 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12344 
12345     /* The 1th argument is a "residual" fast label.  Define its
12346        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
12347        so that at replication time we know what instruction address to patch in. */
12348 #   define JITTER_ARGF1 0
12349     /* JITTER_ARG1 is intentionally not defined for a fast label. */
12350 
12351 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12352 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12353 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12354 
12355 #else
12356   /* Define argument-access macros assuming that fast branches are disabled. */
12357     /* The 0th argument is a nonresidual literal. */
12358 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
12359 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12360 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12361 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12362 #   define JITTER_ARGF0 JITTER_ARGP0
12363 
12364 #if defined(JITTER_DISPATCH_NO_THREADING)
12365 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
12366     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
12367 #elif defined (JITTER_REPLICATE)
12368 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
12369 #else
12370 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
12371 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
12372 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12373 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12374 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12375 #   define JITTER_ARGF1 JITTER_ARGP1
12376 
12377 # endif // #ifdef JITTER_HAVE_PATCH_IN
12378 
12379 #if defined (JITTER_PROFILE_SAMPLE)
12380   JITTER_PROFILE_SAMPLE_UPDATE
12381      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12382       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12383   /* Force the compiler not move sample-profiling instrumentation
12384      beyond this point; this way the actual user code is timed.
12385      This is still not perfect, as residuals are materialised before
12386      we arrive here, but should be adequate at least for slow VM
12387      instructions. */
12388   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12389 #endif
12390 #if defined (JITTER_PROFILE_COUNT)
12391   /* Notice that, differently from the code above, this
12392      instrumentation code *can* be reordered freely: as long as a
12393      VM instruction is counted, the count increment can be placed
12394      anyehere.  Let GCC move this code and possibly achieve better
12395      throughput by exploiting instruction-level parallelism and
12396      therefore approximate more closely a non-profiled build. */
12397   JITTER_PROFILE_COUNT_UPDATE
12398      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12399       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12400 #endif
12401 
12402 /* User-specified code, instruction-beginning-c part: beginning. */
12403 
12404 
12405 /* User-specified code, instruction-beginning-c part: end */
12406 
12407 
12408     /* User code for check-in-arity/n0/fR . */
12409 
12410 #   ifndef JITTERLISP_UNSAFE
12411       /* Here we can assume that the top object is a closure, without checking:
12412          we either already performed a type check, or the compiler decided it
12413          wasn't necessary. */
12414       jitterlisp_object top = JITTER_TOP_MAINSTACK();
12415       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
12416 
12417       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
12418 #   endif // #ifndef JITTERLISP_UNSAFE
12419 
12420     /* End of the user code for check-in-arity/n0/fR . */
12421 
12422 /* User-specified code, instruction-end-c part: beginning. */
12423 
12424 
12425 /* User-specified code, instruction-end-c part: end */
12426 
12427     /* Undefine the check-in-arity/n0/fR argument macros so they can't be used
12428        by mistake in the instruction body coming next. */
12429 #   undef JITTER_SLOW_REGISTER_OFFSET0
12430 #   undef JITTER_ARG0
12431 #   undef JITTER_ARGN0
12432 #   undef JITTER_ARGU0
12433 #   undef JITTER_ARGP0
12434 #   undef JITTER_ARGF0
12435 #   undef JITTER_SLOW_REGISTER_OFFSET1
12436 #   undef JITTER_ARG1
12437 #   undef JITTER_ARGN1
12438 #   undef JITTER_ARGU1
12439 #   undef JITTER_ARGP1
12440 #   undef JITTER_ARGF1
12441 
12442 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12443 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12444 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12445 
12446   }
12447  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n0/fR, check_min_marity__n0__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12448 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12449 
12450   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n1/fR, check_min_marity__n1__fR, hot)
12451   {
12452     /* This specialized instruction is not a replacement. */
12453 #   undef JITTER_BRANCH_FAST
12454 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12455 #   undef JITTER_BRANCH_FAST_IF_ZERO
12456 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12457 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12458 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12459 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12460 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12461 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12462 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12463 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12464 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12465 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12466 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12467 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12468 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12469 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12470 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12471 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12472 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12473 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12474 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12475 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12476 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12477 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12478 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12479 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12480 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12481 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12482 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12483 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12484 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12485 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12486 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12487 #   undef JITTER_BRANCH_FAST_IF_AND
12488 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12489 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12490 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12491 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12492 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12493 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12494 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12495 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12496 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12497 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12498 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12499 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12500 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12501 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12502 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12503 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12504 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12505 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12506 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12507 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12508 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12509 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12510 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12511 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12512 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12513 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12514 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12515 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12516 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12517 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       55
12518 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n1/fR
12519 
12520 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n1__fR
12521 
12522   /* The residual arity varies depending on whether we have fast labels. */
12523 #ifdef JITTER_HAVE_PATCH_IN
12524   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12525 #else
12526   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
12527 #endif // #ifdef JITTER_HAVE_PATCH_IN
12528 
12529   /* Define argument-access macros for check-in-arity/n1/fR . */
12530 #ifdef JITTER_HAVE_PATCH_IN
12531   /* Define argument-access macros assuming that fast branches are enabled. */
12532     /* The 0th argument is a nonresidual literal. */
12533 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
12534 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12535 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12536 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12537 
12538     /* The 1th argument is a "residual" fast label.  Define its
12539        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
12540        so that at replication time we know what instruction address to patch in. */
12541 #   define JITTER_ARGF1 0
12542     /* JITTER_ARG1 is intentionally not defined for a fast label. */
12543 
12544 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12545 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12546 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12547 
12548 #else
12549   /* Define argument-access macros assuming that fast branches are disabled. */
12550     /* The 0th argument is a nonresidual literal. */
12551 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
12552 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12553 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12554 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12555 #   define JITTER_ARGF0 JITTER_ARGP0
12556 
12557 #if defined(JITTER_DISPATCH_NO_THREADING)
12558 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
12559     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
12560 #elif defined (JITTER_REPLICATE)
12561 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
12562 #else
12563 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
12564 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
12565 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12566 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12567 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12568 #   define JITTER_ARGF1 JITTER_ARGP1
12569 
12570 # endif // #ifdef JITTER_HAVE_PATCH_IN
12571 
12572 #if defined (JITTER_PROFILE_SAMPLE)
12573   JITTER_PROFILE_SAMPLE_UPDATE
12574      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12575       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12576   /* Force the compiler not move sample-profiling instrumentation
12577      beyond this point; this way the actual user code is timed.
12578      This is still not perfect, as residuals are materialised before
12579      we arrive here, but should be adequate at least for slow VM
12580      instructions. */
12581   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12582 #endif
12583 #if defined (JITTER_PROFILE_COUNT)
12584   /* Notice that, differently from the code above, this
12585      instrumentation code *can* be reordered freely: as long as a
12586      VM instruction is counted, the count increment can be placed
12587      anyehere.  Let GCC move this code and possibly achieve better
12588      throughput by exploiting instruction-level parallelism and
12589      therefore approximate more closely a non-profiled build. */
12590   JITTER_PROFILE_COUNT_UPDATE
12591      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12592       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12593 #endif
12594 
12595 /* User-specified code, instruction-beginning-c part: beginning. */
12596 
12597 
12598 /* User-specified code, instruction-beginning-c part: end */
12599 
12600 
12601     /* User code for check-in-arity/n1/fR . */
12602 
12603 #   ifndef JITTERLISP_UNSAFE
12604       /* Here we can assume that the top object is a closure, without checking:
12605          we either already performed a type check, or the compiler decided it
12606          wasn't necessary. */
12607       jitterlisp_object top = JITTER_TOP_MAINSTACK();
12608       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
12609 
12610       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
12611 #   endif // #ifndef JITTERLISP_UNSAFE
12612 
12613     /* End of the user code for check-in-arity/n1/fR . */
12614 
12615 /* User-specified code, instruction-end-c part: beginning. */
12616 
12617 
12618 /* User-specified code, instruction-end-c part: end */
12619 
12620     /* Undefine the check-in-arity/n1/fR argument macros so they can't be used
12621        by mistake in the instruction body coming next. */
12622 #   undef JITTER_SLOW_REGISTER_OFFSET0
12623 #   undef JITTER_ARG0
12624 #   undef JITTER_ARGN0
12625 #   undef JITTER_ARGU0
12626 #   undef JITTER_ARGP0
12627 #   undef JITTER_ARGF0
12628 #   undef JITTER_SLOW_REGISTER_OFFSET1
12629 #   undef JITTER_ARG1
12630 #   undef JITTER_ARGN1
12631 #   undef JITTER_ARGU1
12632 #   undef JITTER_ARGP1
12633 #   undef JITTER_ARGF1
12634 
12635 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12636 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12637 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12638 
12639   }
12640  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n1/fR, check_min_marity__n1__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12641 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12642 
12643   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n2/fR, check_min_marity__n2__fR, hot)
12644   {
12645     /* This specialized instruction is not a replacement. */
12646 #   undef JITTER_BRANCH_FAST
12647 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12648 #   undef JITTER_BRANCH_FAST_IF_ZERO
12649 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12650 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12651 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12652 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12653 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12654 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12655 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12656 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12657 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12658 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12659 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12660 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12661 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12662 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12663 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12664 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12665 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12666 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12667 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12668 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12669 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12670 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12671 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12672 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12673 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12674 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12675 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12676 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12677 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12678 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12679 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12680 #   undef JITTER_BRANCH_FAST_IF_AND
12681 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12682 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12683 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12684 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12685 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12686 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12687 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12688 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12689 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12690 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12691 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12692 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12693 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12694 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12695 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12696 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12697 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12698 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12699 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12700 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12701 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12702 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12703 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12704 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12705 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12706 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12707 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12708 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12709 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12710 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       56
12711 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n2/fR
12712 
12713 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n2__fR
12714 
12715   /* The residual arity varies depending on whether we have fast labels. */
12716 #ifdef JITTER_HAVE_PATCH_IN
12717   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12718 #else
12719   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
12720 #endif // #ifdef JITTER_HAVE_PATCH_IN
12721 
12722   /* Define argument-access macros for check-in-arity/n2/fR . */
12723 #ifdef JITTER_HAVE_PATCH_IN
12724   /* Define argument-access macros assuming that fast branches are enabled. */
12725     /* The 0th argument is a nonresidual literal. */
12726 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
12727 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12728 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12729 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12730 
12731     /* The 1th argument is a "residual" fast label.  Define its
12732        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
12733        so that at replication time we know what instruction address to patch in. */
12734 #   define JITTER_ARGF1 0
12735     /* JITTER_ARG1 is intentionally not defined for a fast label. */
12736 
12737 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12738 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12739 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12740 
12741 #else
12742   /* Define argument-access macros assuming that fast branches are disabled. */
12743     /* The 0th argument is a nonresidual literal. */
12744 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
12745 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12746 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12747 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12748 #   define JITTER_ARGF0 JITTER_ARGP0
12749 
12750 #if defined(JITTER_DISPATCH_NO_THREADING)
12751 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
12752     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
12753 #elif defined (JITTER_REPLICATE)
12754 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
12755 #else
12756 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
12757 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
12758 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12759 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12760 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12761 #   define JITTER_ARGF1 JITTER_ARGP1
12762 
12763 # endif // #ifdef JITTER_HAVE_PATCH_IN
12764 
12765 #if defined (JITTER_PROFILE_SAMPLE)
12766   JITTER_PROFILE_SAMPLE_UPDATE
12767      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12768       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12769   /* Force the compiler not move sample-profiling instrumentation
12770      beyond this point; this way the actual user code is timed.
12771      This is still not perfect, as residuals are materialised before
12772      we arrive here, but should be adequate at least for slow VM
12773      instructions. */
12774   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12775 #endif
12776 #if defined (JITTER_PROFILE_COUNT)
12777   /* Notice that, differently from the code above, this
12778      instrumentation code *can* be reordered freely: as long as a
12779      VM instruction is counted, the count increment can be placed
12780      anyehere.  Let GCC move this code and possibly achieve better
12781      throughput by exploiting instruction-level parallelism and
12782      therefore approximate more closely a non-profiled build. */
12783   JITTER_PROFILE_COUNT_UPDATE
12784      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12785       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12786 #endif
12787 
12788 /* User-specified code, instruction-beginning-c part: beginning. */
12789 
12790 
12791 /* User-specified code, instruction-beginning-c part: end */
12792 
12793 
12794     /* User code for check-in-arity/n2/fR . */
12795 
12796 #   ifndef JITTERLISP_UNSAFE
12797       /* Here we can assume that the top object is a closure, without checking:
12798          we either already performed a type check, or the compiler decided it
12799          wasn't necessary. */
12800       jitterlisp_object top = JITTER_TOP_MAINSTACK();
12801       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
12802 
12803       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
12804 #   endif // #ifndef JITTERLISP_UNSAFE
12805 
12806     /* End of the user code for check-in-arity/n2/fR . */
12807 
12808 /* User-specified code, instruction-end-c part: beginning. */
12809 
12810 
12811 /* User-specified code, instruction-end-c part: end */
12812 
12813     /* Undefine the check-in-arity/n2/fR argument macros so they can't be used
12814        by mistake in the instruction body coming next. */
12815 #   undef JITTER_SLOW_REGISTER_OFFSET0
12816 #   undef JITTER_ARG0
12817 #   undef JITTER_ARGN0
12818 #   undef JITTER_ARGU0
12819 #   undef JITTER_ARGP0
12820 #   undef JITTER_ARGF0
12821 #   undef JITTER_SLOW_REGISTER_OFFSET1
12822 #   undef JITTER_ARG1
12823 #   undef JITTER_ARGN1
12824 #   undef JITTER_ARGU1
12825 #   undef JITTER_ARGP1
12826 #   undef JITTER_ARGF1
12827 
12828 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
12829 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
12830 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
12831 
12832   }
12833  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n2/fR, check_min_marity__n2__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
12834 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
12835 
12836   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n3/fR, check_min_marity__n3__fR, hot)
12837   {
12838     /* This specialized instruction is not a replacement. */
12839 #   undef JITTER_BRANCH_FAST
12840 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
12841 #   undef JITTER_BRANCH_FAST_IF_ZERO
12842 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
12843 #   undef JITTER_BRANCH_FAST_IF_NONZERO
12844 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
12845 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
12846 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
12847 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
12848 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
12849 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
12850 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
12851 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
12852 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
12853 #   undef JITTER_BRANCH_FAST_IF_EQUAL
12854 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
12855 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
12856 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
12857 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
12858 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
12859 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12860 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
12861 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12862 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
12863 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12864 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
12865 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12866 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
12867 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12868 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
12869 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12870 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
12871 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12872 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
12873 #   undef JITTER_BRANCH_FAST_IF_AND
12874 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
12875 #   undef JITTER_BRANCH_FAST_IF_NOTAND
12876 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
12877 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12878 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
12879 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12880 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
12881 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12882 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
12883 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12884 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
12885 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12886 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
12887 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12888 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
12889 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12890 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
12891 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12892 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
12893 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12894 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
12895 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12896 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
12897 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12898 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
12899 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12900 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
12901 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12902 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
12903 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       57
12904 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n3/fR
12905 
12906 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n3__fR
12907 
12908   /* The residual arity varies depending on whether we have fast labels. */
12909 #ifdef JITTER_HAVE_PATCH_IN
12910   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
12911 #else
12912   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
12913 #endif // #ifdef JITTER_HAVE_PATCH_IN
12914 
12915   /* Define argument-access macros for check-in-arity/n3/fR . */
12916 #ifdef JITTER_HAVE_PATCH_IN
12917   /* Define argument-access macros assuming that fast branches are enabled. */
12918     /* The 0th argument is a nonresidual literal. */
12919 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
12920 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12921 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12922 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12923 
12924     /* The 1th argument is a "residual" fast label.  Define its
12925        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
12926        so that at replication time we know what instruction address to patch in. */
12927 #   define JITTER_ARGF1 0
12928     /* JITTER_ARG1 is intentionally not defined for a fast label. */
12929 
12930 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12931 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12932 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12933 
12934 #else
12935   /* Define argument-access macros assuming that fast branches are disabled. */
12936     /* The 0th argument is a nonresidual literal. */
12937 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
12938 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
12939 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
12940 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
12941 #   define JITTER_ARGF0 JITTER_ARGP0
12942 
12943 #if defined(JITTER_DISPATCH_NO_THREADING)
12944 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
12945     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
12946 #elif defined (JITTER_REPLICATE)
12947 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
12948 #else
12949 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
12950 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
12951 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
12952 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
12953 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
12954 #   define JITTER_ARGF1 JITTER_ARGP1
12955 
12956 # endif // #ifdef JITTER_HAVE_PATCH_IN
12957 
12958 #if defined (JITTER_PROFILE_SAMPLE)
12959   JITTER_PROFILE_SAMPLE_UPDATE
12960      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12961       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12962   /* Force the compiler not move sample-profiling instrumentation
12963      beyond this point; this way the actual user code is timed.
12964      This is still not perfect, as residuals are materialised before
12965      we arrive here, but should be adequate at least for slow VM
12966      instructions. */
12967   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
12968 #endif
12969 #if defined (JITTER_PROFILE_COUNT)
12970   /* Notice that, differently from the code above, this
12971      instrumentation code *can* be reordered freely: as long as a
12972      VM instruction is counted, the count increment can be placed
12973      anyehere.  Let GCC move this code and possibly achieve better
12974      throughput by exploiting instruction-level parallelism and
12975      therefore approximate more closely a non-profiled build. */
12976   JITTER_PROFILE_COUNT_UPDATE
12977      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
12978       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
12979 #endif
12980 
12981 /* User-specified code, instruction-beginning-c part: beginning. */
12982 
12983 
12984 /* User-specified code, instruction-beginning-c part: end */
12985 
12986 
12987     /* User code for check-in-arity/n3/fR . */
12988 
12989 #   ifndef JITTERLISP_UNSAFE
12990       /* Here we can assume that the top object is a closure, without checking:
12991          we either already performed a type check, or the compiler decided it
12992          wasn't necessary. */
12993       jitterlisp_object top = JITTER_TOP_MAINSTACK();
12994       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
12995 
12996       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
12997 #   endif // #ifndef JITTERLISP_UNSAFE
12998 
12999     /* End of the user code for check-in-arity/n3/fR . */
13000 
13001 /* User-specified code, instruction-end-c part: beginning. */
13002 
13003 
13004 /* User-specified code, instruction-end-c part: end */
13005 
13006     /* Undefine the check-in-arity/n3/fR argument macros so they can't be used
13007        by mistake in the instruction body coming next. */
13008 #   undef JITTER_SLOW_REGISTER_OFFSET0
13009 #   undef JITTER_ARG0
13010 #   undef JITTER_ARGN0
13011 #   undef JITTER_ARGU0
13012 #   undef JITTER_ARGP0
13013 #   undef JITTER_ARGF0
13014 #   undef JITTER_SLOW_REGISTER_OFFSET1
13015 #   undef JITTER_ARG1
13016 #   undef JITTER_ARGN1
13017 #   undef JITTER_ARGU1
13018 #   undef JITTER_ARGP1
13019 #   undef JITTER_ARGF1
13020 
13021 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13022 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13023 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13024 
13025   }
13026  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n3/fR, check_min_marity__n3__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13027 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13028 
13029   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n4/fR, check_min_marity__n4__fR, hot)
13030   {
13031     /* This specialized instruction is not a replacement. */
13032 #   undef JITTER_BRANCH_FAST
13033 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13034 #   undef JITTER_BRANCH_FAST_IF_ZERO
13035 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13036 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13037 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13038 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13039 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13040 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13041 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13042 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13043 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13044 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13045 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13046 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13047 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13048 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13049 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13050 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13051 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13052 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13053 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13054 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13055 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13056 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13057 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13058 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13059 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13060 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13061 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13062 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13063 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13064 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13065 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13066 #   undef JITTER_BRANCH_FAST_IF_AND
13067 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13068 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13069 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13070 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13071 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13072 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13073 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13074 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13075 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13076 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13077 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13078 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13079 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13080 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13081 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13082 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13083 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13084 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13085 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13086 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13087 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13088 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13089 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13090 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13091 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13092 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13093 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13094 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13095 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13096 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       58
13097 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n4/fR
13098 
13099 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n4__fR
13100 
13101   /* The residual arity varies depending on whether we have fast labels. */
13102 #ifdef JITTER_HAVE_PATCH_IN
13103   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13104 #else
13105   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
13106 #endif // #ifdef JITTER_HAVE_PATCH_IN
13107 
13108   /* Define argument-access macros for check-in-arity/n4/fR . */
13109 #ifdef JITTER_HAVE_PATCH_IN
13110   /* Define argument-access macros assuming that fast branches are enabled. */
13111     /* The 0th argument is a nonresidual literal. */
13112 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
13113 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13114 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13115 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13116 
13117     /* The 1th argument is a "residual" fast label.  Define its
13118        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
13119        so that at replication time we know what instruction address to patch in. */
13120 #   define JITTER_ARGF1 0
13121     /* JITTER_ARG1 is intentionally not defined for a fast label. */
13122 
13123 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13124 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13125 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13126 
13127 #else
13128   /* Define argument-access macros assuming that fast branches are disabled. */
13129     /* The 0th argument is a nonresidual literal. */
13130 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
13131 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13132 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13133 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13134 #   define JITTER_ARGF0 JITTER_ARGP0
13135 
13136 #if defined(JITTER_DISPATCH_NO_THREADING)
13137 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
13138     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
13139 #elif defined (JITTER_REPLICATE)
13140 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
13141 #else
13142 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
13143 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
13144 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13145 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13146 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13147 #   define JITTER_ARGF1 JITTER_ARGP1
13148 
13149 # endif // #ifdef JITTER_HAVE_PATCH_IN
13150 
13151 #if defined (JITTER_PROFILE_SAMPLE)
13152   JITTER_PROFILE_SAMPLE_UPDATE
13153      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13154       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13155   /* Force the compiler not move sample-profiling instrumentation
13156      beyond this point; this way the actual user code is timed.
13157      This is still not perfect, as residuals are materialised before
13158      we arrive here, but should be adequate at least for slow VM
13159      instructions. */
13160   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13161 #endif
13162 #if defined (JITTER_PROFILE_COUNT)
13163   /* Notice that, differently from the code above, this
13164      instrumentation code *can* be reordered freely: as long as a
13165      VM instruction is counted, the count increment can be placed
13166      anyehere.  Let GCC move this code and possibly achieve better
13167      throughput by exploiting instruction-level parallelism and
13168      therefore approximate more closely a non-profiled build. */
13169   JITTER_PROFILE_COUNT_UPDATE
13170      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13171       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13172 #endif
13173 
13174 /* User-specified code, instruction-beginning-c part: beginning. */
13175 
13176 
13177 /* User-specified code, instruction-beginning-c part: end */
13178 
13179 
13180     /* User code for check-in-arity/n4/fR . */
13181 
13182 #   ifndef JITTERLISP_UNSAFE
13183       /* Here we can assume that the top object is a closure, without checking:
13184          we either already performed a type check, or the compiler decided it
13185          wasn't necessary. */
13186       jitterlisp_object top = JITTER_TOP_MAINSTACK();
13187       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
13188 
13189       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
13190 #   endif // #ifndef JITTERLISP_UNSAFE
13191 
13192     /* End of the user code for check-in-arity/n4/fR . */
13193 
13194 /* User-specified code, instruction-end-c part: beginning. */
13195 
13196 
13197 /* User-specified code, instruction-end-c part: end */
13198 
13199     /* Undefine the check-in-arity/n4/fR argument macros so they can't be used
13200        by mistake in the instruction body coming next. */
13201 #   undef JITTER_SLOW_REGISTER_OFFSET0
13202 #   undef JITTER_ARG0
13203 #   undef JITTER_ARGN0
13204 #   undef JITTER_ARGU0
13205 #   undef JITTER_ARGP0
13206 #   undef JITTER_ARGF0
13207 #   undef JITTER_SLOW_REGISTER_OFFSET1
13208 #   undef JITTER_ARG1
13209 #   undef JITTER_ARGN1
13210 #   undef JITTER_ARGU1
13211 #   undef JITTER_ARGP1
13212 #   undef JITTER_ARGF1
13213 
13214 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13215 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13216 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13217 
13218   }
13219  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n4/fR, check_min_marity__n4__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13220 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13221 
13222   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n5/fR, check_min_marity__n5__fR, hot)
13223   {
13224     /* This specialized instruction is not a replacement. */
13225 #   undef JITTER_BRANCH_FAST
13226 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13227 #   undef JITTER_BRANCH_FAST_IF_ZERO
13228 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13229 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13230 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13231 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13232 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13233 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13234 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13235 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13236 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13237 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13238 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13239 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13240 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13241 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13242 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13243 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13244 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13245 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13246 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13247 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13248 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13249 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13250 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13251 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13252 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13253 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13254 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13255 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13256 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13257 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13258 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13259 #   undef JITTER_BRANCH_FAST_IF_AND
13260 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13261 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13262 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13263 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13264 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13265 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13266 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13267 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13268 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13269 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13270 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13271 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13272 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13273 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13274 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13275 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13276 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13277 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13278 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13279 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13280 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13281 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13282 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13283 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13284 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13285 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13286 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13287 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13288 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13289 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       59
13290 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n5/fR
13291 
13292 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n5__fR
13293 
13294   /* The residual arity varies depending on whether we have fast labels. */
13295 #ifdef JITTER_HAVE_PATCH_IN
13296   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13297 #else
13298   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
13299 #endif // #ifdef JITTER_HAVE_PATCH_IN
13300 
13301   /* Define argument-access macros for check-in-arity/n5/fR . */
13302 #ifdef JITTER_HAVE_PATCH_IN
13303   /* Define argument-access macros assuming that fast branches are enabled. */
13304     /* The 0th argument is a nonresidual literal. */
13305 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
13306 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13307 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13308 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13309 
13310     /* The 1th argument is a "residual" fast label.  Define its
13311        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
13312        so that at replication time we know what instruction address to patch in. */
13313 #   define JITTER_ARGF1 0
13314     /* JITTER_ARG1 is intentionally not defined for a fast label. */
13315 
13316 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13317 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13318 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13319 
13320 #else
13321   /* Define argument-access macros assuming that fast branches are disabled. */
13322     /* The 0th argument is a nonresidual literal. */
13323 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
13324 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13325 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13326 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13327 #   define JITTER_ARGF0 JITTER_ARGP0
13328 
13329 #if defined(JITTER_DISPATCH_NO_THREADING)
13330 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
13331     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
13332 #elif defined (JITTER_REPLICATE)
13333 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
13334 #else
13335 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
13336 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
13337 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13338 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13339 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13340 #   define JITTER_ARGF1 JITTER_ARGP1
13341 
13342 # endif // #ifdef JITTER_HAVE_PATCH_IN
13343 
13344 #if defined (JITTER_PROFILE_SAMPLE)
13345   JITTER_PROFILE_SAMPLE_UPDATE
13346      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13347       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13348   /* Force the compiler not move sample-profiling instrumentation
13349      beyond this point; this way the actual user code is timed.
13350      This is still not perfect, as residuals are materialised before
13351      we arrive here, but should be adequate at least for slow VM
13352      instructions. */
13353   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13354 #endif
13355 #if defined (JITTER_PROFILE_COUNT)
13356   /* Notice that, differently from the code above, this
13357      instrumentation code *can* be reordered freely: as long as a
13358      VM instruction is counted, the count increment can be placed
13359      anyehere.  Let GCC move this code and possibly achieve better
13360      throughput by exploiting instruction-level parallelism and
13361      therefore approximate more closely a non-profiled build. */
13362   JITTER_PROFILE_COUNT_UPDATE
13363      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13364       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13365 #endif
13366 
13367 /* User-specified code, instruction-beginning-c part: beginning. */
13368 
13369 
13370 /* User-specified code, instruction-beginning-c part: end */
13371 
13372 
13373     /* User code for check-in-arity/n5/fR . */
13374 
13375 #   ifndef JITTERLISP_UNSAFE
13376       /* Here we can assume that the top object is a closure, without checking:
13377          we either already performed a type check, or the compiler decided it
13378          wasn't necessary. */
13379       jitterlisp_object top = JITTER_TOP_MAINSTACK();
13380       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
13381 
13382       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
13383 #   endif // #ifndef JITTERLISP_UNSAFE
13384 
13385     /* End of the user code for check-in-arity/n5/fR . */
13386 
13387 /* User-specified code, instruction-end-c part: beginning. */
13388 
13389 
13390 /* User-specified code, instruction-end-c part: end */
13391 
13392     /* Undefine the check-in-arity/n5/fR argument macros so they can't be used
13393        by mistake in the instruction body coming next. */
13394 #   undef JITTER_SLOW_REGISTER_OFFSET0
13395 #   undef JITTER_ARG0
13396 #   undef JITTER_ARGN0
13397 #   undef JITTER_ARGU0
13398 #   undef JITTER_ARGP0
13399 #   undef JITTER_ARGF0
13400 #   undef JITTER_SLOW_REGISTER_OFFSET1
13401 #   undef JITTER_ARG1
13402 #   undef JITTER_ARGN1
13403 #   undef JITTER_ARGU1
13404 #   undef JITTER_ARGP1
13405 #   undef JITTER_ARGF1
13406 
13407 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13408 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13409 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13410 
13411   }
13412  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n5/fR, check_min_marity__n5__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13413 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13414 
13415   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n6/fR, check_min_marity__n6__fR, hot)
13416   {
13417     /* This specialized instruction is not a replacement. */
13418 #   undef JITTER_BRANCH_FAST
13419 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13420 #   undef JITTER_BRANCH_FAST_IF_ZERO
13421 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13422 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13423 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13424 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13425 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13426 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13427 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13428 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13429 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13430 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13431 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13432 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13433 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13434 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13435 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13436 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13437 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13438 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13439 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13440 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13441 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13442 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13443 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13444 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13445 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13446 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13447 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13448 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13449 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13450 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13451 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13452 #   undef JITTER_BRANCH_FAST_IF_AND
13453 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13454 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13455 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13456 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13457 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13458 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13459 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13460 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13461 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13462 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13463 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13464 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13465 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13466 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13467 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13468 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13469 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13470 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13471 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13472 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13473 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13474 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13475 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13476 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13477 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13478 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13479 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13480 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13481 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13482 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       60
13483 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n6/fR
13484 
13485 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n6__fR
13486 
13487   /* The residual arity varies depending on whether we have fast labels. */
13488 #ifdef JITTER_HAVE_PATCH_IN
13489   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13490 #else
13491   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
13492 #endif // #ifdef JITTER_HAVE_PATCH_IN
13493 
13494   /* Define argument-access macros for check-in-arity/n6/fR . */
13495 #ifdef JITTER_HAVE_PATCH_IN
13496   /* Define argument-access macros assuming that fast branches are enabled. */
13497     /* The 0th argument is a nonresidual literal. */
13498 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
13499 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13500 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13501 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13502 
13503     /* The 1th argument is a "residual" fast label.  Define its
13504        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
13505        so that at replication time we know what instruction address to patch in. */
13506 #   define JITTER_ARGF1 0
13507     /* JITTER_ARG1 is intentionally not defined for a fast label. */
13508 
13509 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13510 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13511 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13512 
13513 #else
13514   /* Define argument-access macros assuming that fast branches are disabled. */
13515     /* The 0th argument is a nonresidual literal. */
13516 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
13517 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13518 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13519 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13520 #   define JITTER_ARGF0 JITTER_ARGP0
13521 
13522 #if defined(JITTER_DISPATCH_NO_THREADING)
13523 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
13524     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
13525 #elif defined (JITTER_REPLICATE)
13526 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
13527 #else
13528 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
13529 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
13530 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13531 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13532 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13533 #   define JITTER_ARGF1 JITTER_ARGP1
13534 
13535 # endif // #ifdef JITTER_HAVE_PATCH_IN
13536 
13537 #if defined (JITTER_PROFILE_SAMPLE)
13538   JITTER_PROFILE_SAMPLE_UPDATE
13539      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13540       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13541   /* Force the compiler not move sample-profiling instrumentation
13542      beyond this point; this way the actual user code is timed.
13543      This is still not perfect, as residuals are materialised before
13544      we arrive here, but should be adequate at least for slow VM
13545      instructions. */
13546   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13547 #endif
13548 #if defined (JITTER_PROFILE_COUNT)
13549   /* Notice that, differently from the code above, this
13550      instrumentation code *can* be reordered freely: as long as a
13551      VM instruction is counted, the count increment can be placed
13552      anyehere.  Let GCC move this code and possibly achieve better
13553      throughput by exploiting instruction-level parallelism and
13554      therefore approximate more closely a non-profiled build. */
13555   JITTER_PROFILE_COUNT_UPDATE
13556      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13557       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13558 #endif
13559 
13560 /* User-specified code, instruction-beginning-c part: beginning. */
13561 
13562 
13563 /* User-specified code, instruction-beginning-c part: end */
13564 
13565 
13566     /* User code for check-in-arity/n6/fR . */
13567 
13568 #   ifndef JITTERLISP_UNSAFE
13569       /* Here we can assume that the top object is a closure, without checking:
13570          we either already performed a type check, or the compiler decided it
13571          wasn't necessary. */
13572       jitterlisp_object top = JITTER_TOP_MAINSTACK();
13573       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
13574 
13575       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
13576 #   endif // #ifndef JITTERLISP_UNSAFE
13577 
13578     /* End of the user code for check-in-arity/n6/fR . */
13579 
13580 /* User-specified code, instruction-end-c part: beginning. */
13581 
13582 
13583 /* User-specified code, instruction-end-c part: end */
13584 
13585     /* Undefine the check-in-arity/n6/fR argument macros so they can't be used
13586        by mistake in the instruction body coming next. */
13587 #   undef JITTER_SLOW_REGISTER_OFFSET0
13588 #   undef JITTER_ARG0
13589 #   undef JITTER_ARGN0
13590 #   undef JITTER_ARGU0
13591 #   undef JITTER_ARGP0
13592 #   undef JITTER_ARGF0
13593 #   undef JITTER_SLOW_REGISTER_OFFSET1
13594 #   undef JITTER_ARG1
13595 #   undef JITTER_ARGN1
13596 #   undef JITTER_ARGU1
13597 #   undef JITTER_ARGP1
13598 #   undef JITTER_ARGF1
13599 
13600 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13601 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13602 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13603 
13604   }
13605  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n6/fR, check_min_marity__n6__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13606 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13607 
13608   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n7/fR, check_min_marity__n7__fR, hot)
13609   {
13610     /* This specialized instruction is not a replacement. */
13611 #   undef JITTER_BRANCH_FAST
13612 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13613 #   undef JITTER_BRANCH_FAST_IF_ZERO
13614 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13615 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13616 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13617 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13618 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13619 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13620 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13621 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13622 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13623 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13624 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13625 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13626 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13627 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13628 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13629 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13630 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13631 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13632 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13633 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13634 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13635 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13636 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13637 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13638 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13639 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13640 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13641 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13642 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13643 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13644 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13645 #   undef JITTER_BRANCH_FAST_IF_AND
13646 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13647 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13648 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13649 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13650 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13651 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13652 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13653 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13654 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13655 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13656 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13657 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13658 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13659 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13660 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13661 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13662 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13663 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13664 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13665 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13666 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13667 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13668 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13669 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13670 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13671 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13672 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13673 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13674 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13675 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       61
13676 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n7/fR
13677 
13678 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n7__fR
13679 
13680   /* The residual arity varies depending on whether we have fast labels. */
13681 #ifdef JITTER_HAVE_PATCH_IN
13682   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13683 #else
13684   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
13685 #endif // #ifdef JITTER_HAVE_PATCH_IN
13686 
13687   /* Define argument-access macros for check-in-arity/n7/fR . */
13688 #ifdef JITTER_HAVE_PATCH_IN
13689   /* Define argument-access macros assuming that fast branches are enabled. */
13690     /* The 0th argument is a nonresidual literal. */
13691 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
13692 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13693 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13694 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13695 
13696     /* The 1th argument is a "residual" fast label.  Define its
13697        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
13698        so that at replication time we know what instruction address to patch in. */
13699 #   define JITTER_ARGF1 0
13700     /* JITTER_ARG1 is intentionally not defined for a fast label. */
13701 
13702 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13703 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13704 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13705 
13706 #else
13707   /* Define argument-access macros assuming that fast branches are disabled. */
13708     /* The 0th argument is a nonresidual literal. */
13709 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
13710 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13711 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13712 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13713 #   define JITTER_ARGF0 JITTER_ARGP0
13714 
13715 #if defined(JITTER_DISPATCH_NO_THREADING)
13716 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
13717     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
13718 #elif defined (JITTER_REPLICATE)
13719 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
13720 #else
13721 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
13722 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
13723 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13724 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13725 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13726 #   define JITTER_ARGF1 JITTER_ARGP1
13727 
13728 # endif // #ifdef JITTER_HAVE_PATCH_IN
13729 
13730 #if defined (JITTER_PROFILE_SAMPLE)
13731   JITTER_PROFILE_SAMPLE_UPDATE
13732      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13733       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13734   /* Force the compiler not move sample-profiling instrumentation
13735      beyond this point; this way the actual user code is timed.
13736      This is still not perfect, as residuals are materialised before
13737      we arrive here, but should be adequate at least for slow VM
13738      instructions. */
13739   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13740 #endif
13741 #if defined (JITTER_PROFILE_COUNT)
13742   /* Notice that, differently from the code above, this
13743      instrumentation code *can* be reordered freely: as long as a
13744      VM instruction is counted, the count increment can be placed
13745      anyehere.  Let GCC move this code and possibly achieve better
13746      throughput by exploiting instruction-level parallelism and
13747      therefore approximate more closely a non-profiled build. */
13748   JITTER_PROFILE_COUNT_UPDATE
13749      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13750       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13751 #endif
13752 
13753 /* User-specified code, instruction-beginning-c part: beginning. */
13754 
13755 
13756 /* User-specified code, instruction-beginning-c part: end */
13757 
13758 
13759     /* User code for check-in-arity/n7/fR . */
13760 
13761 #   ifndef JITTERLISP_UNSAFE
13762       /* Here we can assume that the top object is a closure, without checking:
13763          we either already performed a type check, or the compiler decided it
13764          wasn't necessary. */
13765       jitterlisp_object top = JITTER_TOP_MAINSTACK();
13766       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
13767 
13768       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
13769 #   endif // #ifndef JITTERLISP_UNSAFE
13770 
13771     /* End of the user code for check-in-arity/n7/fR . */
13772 
13773 /* User-specified code, instruction-end-c part: beginning. */
13774 
13775 
13776 /* User-specified code, instruction-end-c part: end */
13777 
13778     /* Undefine the check-in-arity/n7/fR argument macros so they can't be used
13779        by mistake in the instruction body coming next. */
13780 #   undef JITTER_SLOW_REGISTER_OFFSET0
13781 #   undef JITTER_ARG0
13782 #   undef JITTER_ARGN0
13783 #   undef JITTER_ARGU0
13784 #   undef JITTER_ARGP0
13785 #   undef JITTER_ARGF0
13786 #   undef JITTER_SLOW_REGISTER_OFFSET1
13787 #   undef JITTER_ARG1
13788 #   undef JITTER_ARGN1
13789 #   undef JITTER_ARGU1
13790 #   undef JITTER_ARGP1
13791 #   undef JITTER_ARGF1
13792 
13793 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13794 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13795 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13796 
13797   }
13798  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n7/fR, check_min_marity__n7__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13799 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13800 
13801   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n8/fR, check_min_marity__n8__fR, hot)
13802   {
13803     /* This specialized instruction is not a replacement. */
13804 #   undef JITTER_BRANCH_FAST
13805 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13806 #   undef JITTER_BRANCH_FAST_IF_ZERO
13807 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
13808 #   undef JITTER_BRANCH_FAST_IF_NONZERO
13809 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
13810 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
13811 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
13812 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
13813 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
13814 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
13815 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
13816 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
13817 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
13818 #   undef JITTER_BRANCH_FAST_IF_EQUAL
13819 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
13820 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
13821 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
13822 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
13823 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
13824 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13825 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
13826 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13827 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
13828 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13829 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
13830 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13831 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
13832 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13833 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
13834 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13835 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
13836 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13837 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
13838 #   undef JITTER_BRANCH_FAST_IF_AND
13839 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
13840 #   undef JITTER_BRANCH_FAST_IF_NOTAND
13841 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
13842 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13843 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
13844 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13845 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
13846 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13847 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
13848 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13849 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
13850 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13851 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
13852 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13853 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
13854 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13855 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
13856 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13857 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
13858 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13859 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
13860 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13861 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
13862 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13863 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
13864 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13865 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
13866 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13867 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
13868 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       62
13869 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n8/fR
13870 
13871 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n8__fR
13872 
13873   /* The residual arity varies depending on whether we have fast labels. */
13874 #ifdef JITTER_HAVE_PATCH_IN
13875   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
13876 #else
13877   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
13878 #endif // #ifdef JITTER_HAVE_PATCH_IN
13879 
13880   /* Define argument-access macros for check-in-arity/n8/fR . */
13881 #ifdef JITTER_HAVE_PATCH_IN
13882   /* Define argument-access macros assuming that fast branches are enabled. */
13883     /* The 0th argument is a nonresidual literal. */
13884 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
13885 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13886 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13887 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13888 
13889     /* The 1th argument is a "residual" fast label.  Define its
13890        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
13891        so that at replication time we know what instruction address to patch in. */
13892 #   define JITTER_ARGF1 0
13893     /* JITTER_ARG1 is intentionally not defined for a fast label. */
13894 
13895 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13896 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13897 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13898 
13899 #else
13900   /* Define argument-access macros assuming that fast branches are disabled. */
13901     /* The 0th argument is a nonresidual literal. */
13902 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
13903 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
13904 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
13905 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
13906 #   define JITTER_ARGF0 JITTER_ARGP0
13907 
13908 #if defined(JITTER_DISPATCH_NO_THREADING)
13909 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
13910     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
13911 #elif defined (JITTER_REPLICATE)
13912 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
13913 #else
13914 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
13915 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
13916 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
13917 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
13918 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
13919 #   define JITTER_ARGF1 JITTER_ARGP1
13920 
13921 # endif // #ifdef JITTER_HAVE_PATCH_IN
13922 
13923 #if defined (JITTER_PROFILE_SAMPLE)
13924   JITTER_PROFILE_SAMPLE_UPDATE
13925      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13926       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13927   /* Force the compiler not move sample-profiling instrumentation
13928      beyond this point; this way the actual user code is timed.
13929      This is still not perfect, as residuals are materialised before
13930      we arrive here, but should be adequate at least for slow VM
13931      instructions. */
13932   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
13933 #endif
13934 #if defined (JITTER_PROFILE_COUNT)
13935   /* Notice that, differently from the code above, this
13936      instrumentation code *can* be reordered freely: as long as a
13937      VM instruction is counted, the count increment can be placed
13938      anyehere.  Let GCC move this code and possibly achieve better
13939      throughput by exploiting instruction-level parallelism and
13940      therefore approximate more closely a non-profiled build. */
13941   JITTER_PROFILE_COUNT_UPDATE
13942      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
13943       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
13944 #endif
13945 
13946 /* User-specified code, instruction-beginning-c part: beginning. */
13947 
13948 
13949 /* User-specified code, instruction-beginning-c part: end */
13950 
13951 
13952     /* User code for check-in-arity/n8/fR . */
13953 
13954 #   ifndef JITTERLISP_UNSAFE
13955       /* Here we can assume that the top object is a closure, without checking:
13956          we either already performed a type check, or the compiler decided it
13957          wasn't necessary. */
13958       jitterlisp_object top = JITTER_TOP_MAINSTACK();
13959       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
13960 
13961       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
13962 #   endif // #ifndef JITTERLISP_UNSAFE
13963 
13964     /* End of the user code for check-in-arity/n8/fR . */
13965 
13966 /* User-specified code, instruction-end-c part: beginning. */
13967 
13968 
13969 /* User-specified code, instruction-end-c part: end */
13970 
13971     /* Undefine the check-in-arity/n8/fR argument macros so they can't be used
13972        by mistake in the instruction body coming next. */
13973 #   undef JITTER_SLOW_REGISTER_OFFSET0
13974 #   undef JITTER_ARG0
13975 #   undef JITTER_ARGN0
13976 #   undef JITTER_ARGU0
13977 #   undef JITTER_ARGP0
13978 #   undef JITTER_ARGF0
13979 #   undef JITTER_SLOW_REGISTER_OFFSET1
13980 #   undef JITTER_ARG1
13981 #   undef JITTER_ARGN1
13982 #   undef JITTER_ARGU1
13983 #   undef JITTER_ARGP1
13984 #   undef JITTER_ARGF1
13985 
13986 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
13987 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
13988 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
13989 
13990   }
13991  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n8/fR, check_min_marity__n8__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
13992 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
13993 
13994   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n9/fR, check_min_marity__n9__fR, hot)
13995   {
13996     /* This specialized instruction is not a replacement. */
13997 #   undef JITTER_BRANCH_FAST
13998 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
13999 #   undef JITTER_BRANCH_FAST_IF_ZERO
14000 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14001 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14002 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14003 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14004 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14005 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14006 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14007 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14008 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14009 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14010 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14011 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14012 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14013 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14014 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14015 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14016 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14017 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14018 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14019 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14020 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14021 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14022 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14023 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14024 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14025 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14026 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14027 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14028 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14029 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14030 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14031 #   undef JITTER_BRANCH_FAST_IF_AND
14032 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14033 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14034 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14035 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14036 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14037 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14038 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14039 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14040 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14041 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14042 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14043 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14044 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14045 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14046 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14047 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14048 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14049 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14050 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14051 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14052 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14053 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14054 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14055 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14056 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14057 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14058 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14059 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14060 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14061 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       63
14062 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n9/fR
14063 
14064 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n9__fR
14065 
14066   /* The residual arity varies depending on whether we have fast labels. */
14067 #ifdef JITTER_HAVE_PATCH_IN
14068   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14069 #else
14070   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
14071 #endif // #ifdef JITTER_HAVE_PATCH_IN
14072 
14073   /* Define argument-access macros for check-in-arity/n9/fR . */
14074 #ifdef JITTER_HAVE_PATCH_IN
14075   /* Define argument-access macros assuming that fast branches are enabled. */
14076     /* The 0th argument is a nonresidual literal. */
14077 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
14078 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14079 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14080 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14081 
14082     /* The 1th argument is a "residual" fast label.  Define its
14083        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
14084        so that at replication time we know what instruction address to patch in. */
14085 #   define JITTER_ARGF1 0
14086     /* JITTER_ARG1 is intentionally not defined for a fast label. */
14087 
14088 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14089 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14090 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14091 
14092 #else
14093   /* Define argument-access macros assuming that fast branches are disabled. */
14094     /* The 0th argument is a nonresidual literal. */
14095 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
14096 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14097 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14098 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14099 #   define JITTER_ARGF0 JITTER_ARGP0
14100 
14101 #if defined(JITTER_DISPATCH_NO_THREADING)
14102 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
14103     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
14104 #elif defined (JITTER_REPLICATE)
14105 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
14106 #else
14107 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
14108 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
14109 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14110 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14111 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14112 #   define JITTER_ARGF1 JITTER_ARGP1
14113 
14114 # endif // #ifdef JITTER_HAVE_PATCH_IN
14115 
14116 #if defined (JITTER_PROFILE_SAMPLE)
14117   JITTER_PROFILE_SAMPLE_UPDATE
14118      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14119       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14120   /* Force the compiler not move sample-profiling instrumentation
14121      beyond this point; this way the actual user code is timed.
14122      This is still not perfect, as residuals are materialised before
14123      we arrive here, but should be adequate at least for slow VM
14124      instructions. */
14125   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14126 #endif
14127 #if defined (JITTER_PROFILE_COUNT)
14128   /* Notice that, differently from the code above, this
14129      instrumentation code *can* be reordered freely: as long as a
14130      VM instruction is counted, the count increment can be placed
14131      anyehere.  Let GCC move this code and possibly achieve better
14132      throughput by exploiting instruction-level parallelism and
14133      therefore approximate more closely a non-profiled build. */
14134   JITTER_PROFILE_COUNT_UPDATE
14135      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14136       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14137 #endif
14138 
14139 /* User-specified code, instruction-beginning-c part: beginning. */
14140 
14141 
14142 /* User-specified code, instruction-beginning-c part: end */
14143 
14144 
14145     /* User code for check-in-arity/n9/fR . */
14146 
14147 #   ifndef JITTERLISP_UNSAFE
14148       /* Here we can assume that the top object is a closure, without checking:
14149          we either already performed a type check, or the compiler decided it
14150          wasn't necessary. */
14151       jitterlisp_object top = JITTER_TOP_MAINSTACK();
14152       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
14153 
14154       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
14155 #   endif // #ifndef JITTERLISP_UNSAFE
14156 
14157     /* End of the user code for check-in-arity/n9/fR . */
14158 
14159 /* User-specified code, instruction-end-c part: beginning. */
14160 
14161 
14162 /* User-specified code, instruction-end-c part: end */
14163 
14164     /* Undefine the check-in-arity/n9/fR argument macros so they can't be used
14165        by mistake in the instruction body coming next. */
14166 #   undef JITTER_SLOW_REGISTER_OFFSET0
14167 #   undef JITTER_ARG0
14168 #   undef JITTER_ARGN0
14169 #   undef JITTER_ARGU0
14170 #   undef JITTER_ARGP0
14171 #   undef JITTER_ARGF0
14172 #   undef JITTER_SLOW_REGISTER_OFFSET1
14173 #   undef JITTER_ARG1
14174 #   undef JITTER_ARGN1
14175 #   undef JITTER_ARGU1
14176 #   undef JITTER_ARGP1
14177 #   undef JITTER_ARGF1
14178 
14179 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14180 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14181 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14182 
14183   }
14184  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n9/fR, check_min_marity__n9__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14185 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14186 
14187   JITTER_INSTRUCTION_PROLOG_(check-in-arity/n10/fR, check_min_marity__n10__fR, hot)
14188   {
14189     /* This specialized instruction is not a replacement. */
14190 #   undef JITTER_BRANCH_FAST
14191 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14192 #   undef JITTER_BRANCH_FAST_IF_ZERO
14193 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14194 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14195 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14196 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14197 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14198 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14199 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14200 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14201 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14202 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14203 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14204 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14205 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14206 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14207 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14208 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14209 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14210 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14211 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14212 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14213 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14214 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14215 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14216 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14217 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14218 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14219 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14220 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14221 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14222 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14223 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14224 #   undef JITTER_BRANCH_FAST_IF_AND
14225 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14226 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14227 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14228 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14229 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14230 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14231 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14232 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14233 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14234 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14235 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14236 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14237 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14238 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14239 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14240 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14241 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14242 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14243 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14244 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14245 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14246 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14247 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14248 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14249 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14250 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14251 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14252 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14253 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14254 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       64
14255 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/n10/fR
14256 
14257 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__n10__fR
14258 
14259   /* The residual arity varies depending on whether we have fast labels. */
14260 #ifdef JITTER_HAVE_PATCH_IN
14261   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14262 #else
14263   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
14264 #endif // #ifdef JITTER_HAVE_PATCH_IN
14265 
14266   /* Define argument-access macros for check-in-arity/n10/fR . */
14267 #ifdef JITTER_HAVE_PATCH_IN
14268   /* Define argument-access macros assuming that fast branches are enabled. */
14269     /* The 0th argument is a nonresidual literal. */
14270 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
14271 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14272 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14273 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14274 
14275     /* The 1th argument is a "residual" fast label.  Define its
14276        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
14277        so that at replication time we know what instruction address to patch in. */
14278 #   define JITTER_ARGF1 0
14279     /* JITTER_ARG1 is intentionally not defined for a fast label. */
14280 
14281 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14282 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14283 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14284 
14285 #else
14286   /* Define argument-access macros assuming that fast branches are disabled. */
14287     /* The 0th argument is a nonresidual literal. */
14288 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
14289 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14290 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14291 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14292 #   define JITTER_ARGF0 JITTER_ARGP0
14293 
14294 #if defined(JITTER_DISPATCH_NO_THREADING)
14295 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
14296     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
14297 #elif defined (JITTER_REPLICATE)
14298 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
14299 #else
14300 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
14301 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
14302 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14303 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14304 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14305 #   define JITTER_ARGF1 JITTER_ARGP1
14306 
14307 # endif // #ifdef JITTER_HAVE_PATCH_IN
14308 
14309 #if defined (JITTER_PROFILE_SAMPLE)
14310   JITTER_PROFILE_SAMPLE_UPDATE
14311      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14312       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14313   /* Force the compiler not move sample-profiling instrumentation
14314      beyond this point; this way the actual user code is timed.
14315      This is still not perfect, as residuals are materialised before
14316      we arrive here, but should be adequate at least for slow VM
14317      instructions. */
14318   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14319 #endif
14320 #if defined (JITTER_PROFILE_COUNT)
14321   /* Notice that, differently from the code above, this
14322      instrumentation code *can* be reordered freely: as long as a
14323      VM instruction is counted, the count increment can be placed
14324      anyehere.  Let GCC move this code and possibly achieve better
14325      throughput by exploiting instruction-level parallelism and
14326      therefore approximate more closely a non-profiled build. */
14327   JITTER_PROFILE_COUNT_UPDATE
14328      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14329       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14330 #endif
14331 
14332 /* User-specified code, instruction-beginning-c part: beginning. */
14333 
14334 
14335 /* User-specified code, instruction-beginning-c part: end */
14336 
14337 
14338     /* User code for check-in-arity/n10/fR . */
14339 
14340 #   ifndef JITTERLISP_UNSAFE
14341       /* Here we can assume that the top object is a closure, without checking:
14342          we either already performed a type check, or the compiler decided it
14343          wasn't necessary. */
14344       jitterlisp_object top = JITTER_TOP_MAINSTACK();
14345       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
14346 
14347       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
14348 #   endif // #ifndef JITTERLISP_UNSAFE
14349 
14350     /* End of the user code for check-in-arity/n10/fR . */
14351 
14352 /* User-specified code, instruction-end-c part: beginning. */
14353 
14354 
14355 /* User-specified code, instruction-end-c part: end */
14356 
14357     /* Undefine the check-in-arity/n10/fR argument macros so they can't be used
14358        by mistake in the instruction body coming next. */
14359 #   undef JITTER_SLOW_REGISTER_OFFSET0
14360 #   undef JITTER_ARG0
14361 #   undef JITTER_ARGN0
14362 #   undef JITTER_ARGU0
14363 #   undef JITTER_ARGP0
14364 #   undef JITTER_ARGF0
14365 #   undef JITTER_SLOW_REGISTER_OFFSET1
14366 #   undef JITTER_ARG1
14367 #   undef JITTER_ARGN1
14368 #   undef JITTER_ARGU1
14369 #   undef JITTER_ARGP1
14370 #   undef JITTER_ARGF1
14371 
14372 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14373 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14374 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14375 
14376   }
14377  JITTER_INSTRUCTION_EPILOG_(check-in-arity/n10/fR, check_min_marity__n10__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14378 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14379 
14380   JITTER_INSTRUCTION_PROLOG_(check-in-arity/nR/fR, check_min_marity__nR__fR, cold)
14381   {
14382     /* This specialized instruction is not a replacement. */
14383 #   undef JITTER_BRANCH_FAST
14384 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14385 #   undef JITTER_BRANCH_FAST_IF_ZERO
14386 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14387 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14388 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14389 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14390 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14391 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14392 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14393 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14394 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14395 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14396 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14397 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14398 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14399 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14400 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14401 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14402 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14403 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14404 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14405 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14406 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14407 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14408 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14409 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14410 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14411 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14412 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14413 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14414 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14415 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14416 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14417 #   undef JITTER_BRANCH_FAST_IF_AND
14418 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14419 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14420 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14421 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14422 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14423 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14424 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14425 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14426 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14427 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14428 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14429 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14430 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14431 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14432 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14433 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14434 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14435 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14436 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14437 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14438 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14439 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14440 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14441 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14442 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14443 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14444 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14445 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14446 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14447 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       65
14448 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity/nR/fR
14449 
14450 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity__nR__fR
14451 
14452   /* The residual arity varies depending on whether we have fast labels. */
14453 #ifdef JITTER_HAVE_PATCH_IN
14454   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
14455 #else
14456   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
14457 #endif // #ifdef JITTER_HAVE_PATCH_IN
14458 
14459   /* Define argument-access macros for check-in-arity/nR/fR . */
14460 #ifdef JITTER_HAVE_PATCH_IN
14461   /* Define argument-access macros assuming that fast branches are enabled. */
14462     /* The 0th argument is a residual literal. */
14463 #if defined(JITTER_DISPATCH_NO_THREADING)
14464 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
14465     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
14466 #elif defined (JITTER_REPLICATE)
14467 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
14468 #else
14469 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
14470 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
14471 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14472 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14473 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14474 
14475     /* The 1th argument is a "residual" fast label.  Define its
14476        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
14477        so that at replication time we know what instruction address to patch in. */
14478 #   define JITTER_ARGF1 0
14479     /* JITTER_ARG1 is intentionally not defined for a fast label. */
14480 
14481 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14482 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14483 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14484 
14485 #else
14486   /* Define argument-access macros assuming that fast branches are disabled. */
14487     /* The 0th argument is a residual literal. */
14488 #if defined(JITTER_DISPATCH_NO_THREADING)
14489 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
14490     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
14491 #elif defined (JITTER_REPLICATE)
14492 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
14493 #else
14494 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
14495 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
14496 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14497 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14498 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14499 #   define JITTER_ARGF0 JITTER_ARGP0
14500 
14501 #if defined(JITTER_DISPATCH_NO_THREADING)
14502 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
14503     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
14504 #elif defined (JITTER_REPLICATE)
14505 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
14506 #else
14507 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
14508 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
14509 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14510 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14511 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14512 #   define JITTER_ARGF1 JITTER_ARGP1
14513 
14514 # endif // #ifdef JITTER_HAVE_PATCH_IN
14515 
14516 #if defined (JITTER_PROFILE_SAMPLE)
14517   JITTER_PROFILE_SAMPLE_UPDATE
14518      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14519       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14520   /* Force the compiler not move sample-profiling instrumentation
14521      beyond this point; this way the actual user code is timed.
14522      This is still not perfect, as residuals are materialised before
14523      we arrive here, but should be adequate at least for slow VM
14524      instructions. */
14525   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14526 #endif
14527 #if defined (JITTER_PROFILE_COUNT)
14528   /* Notice that, differently from the code above, this
14529      instrumentation code *can* be reordered freely: as long as a
14530      VM instruction is counted, the count increment can be placed
14531      anyehere.  Let GCC move this code and possibly achieve better
14532      throughput by exploiting instruction-level parallelism and
14533      therefore approximate more closely a non-profiled build. */
14534   JITTER_PROFILE_COUNT_UPDATE
14535      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14536       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14537 #endif
14538 
14539 /* User-specified code, instruction-beginning-c part: beginning. */
14540 
14541 
14542 /* User-specified code, instruction-beginning-c part: end */
14543 
14544 
14545     /* User code for check-in-arity/nR/fR . */
14546 
14547 #   ifndef JITTERLISP_UNSAFE
14548       /* Here we can assume that the top object is a closure, without checking:
14549          we either already performed a type check, or the compiler decided it
14550          wasn't necessary. */
14551       jitterlisp_object top = JITTER_TOP_MAINSTACK();
14552       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
14553 
14554       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
14555 #   endif // #ifndef JITTERLISP_UNSAFE
14556 
14557     /* End of the user code for check-in-arity/nR/fR . */
14558 
14559 /* User-specified code, instruction-end-c part: beginning. */
14560 
14561 
14562 /* User-specified code, instruction-end-c part: end */
14563 
14564     /* Undefine the check-in-arity/nR/fR argument macros so they can't be used
14565        by mistake in the instruction body coming next. */
14566 #   undef JITTER_SLOW_REGISTER_OFFSET0
14567 #   undef JITTER_ARG0
14568 #   undef JITTER_ARGN0
14569 #   undef JITTER_ARGU0
14570 #   undef JITTER_ARGP0
14571 #   undef JITTER_ARGF0
14572 #   undef JITTER_SLOW_REGISTER_OFFSET1
14573 #   undef JITTER_ARG1
14574 #   undef JITTER_ARGN1
14575 #   undef JITTER_ARGU1
14576 #   undef JITTER_ARGP1
14577 #   undef JITTER_ARGF1
14578 
14579 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14580 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14581 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14582 
14583   }
14584  JITTER_INSTRUCTION_EPILOG_(check-in-arity/nR/fR, check_min_marity__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14585 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14586 
14587   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n0/fR, check_min_marity_m_malt__n0__fR, hot)
14588   {
14589     /* This specialized instruction is not a replacement. */
14590 #   undef JITTER_BRANCH_FAST
14591 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14592 #   undef JITTER_BRANCH_FAST_IF_ZERO
14593 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14594 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14595 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14596 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14597 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14598 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14599 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14600 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14601 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14602 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14603 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14604 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14605 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14606 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14607 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14608 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14609 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14610 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14611 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14612 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14613 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14614 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14615 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14616 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14617 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14618 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14619 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14620 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14621 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14622 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14623 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14624 #   undef JITTER_BRANCH_FAST_IF_AND
14625 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14626 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14627 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14628 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14629 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14630 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14631 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14632 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14633 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14634 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14635 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14636 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14637 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14638 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14639 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14640 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14641 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14642 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14643 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14644 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14645 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14646 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14647 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14648 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14649 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14650 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14651 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14652 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14653 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14654 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       66
14655 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n0/fR
14656 
14657 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n0__fR
14658 
14659   /* The residual arity varies depending on whether we have fast labels. */
14660 #ifdef JITTER_HAVE_PATCH_IN
14661   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14662 #else
14663   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
14664 #endif // #ifdef JITTER_HAVE_PATCH_IN
14665 
14666   /* Define argument-access macros for check-in-arity--alt/n0/fR . */
14667 #ifdef JITTER_HAVE_PATCH_IN
14668   /* Define argument-access macros assuming that fast branches are enabled. */
14669     /* The 0th argument is a nonresidual literal. */
14670 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
14671 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14672 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14673 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14674 
14675     /* The 1th argument is a "residual" fast label.  Define its
14676        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
14677        so that at replication time we know what instruction address to patch in. */
14678 #   define JITTER_ARGF1 0
14679     /* JITTER_ARG1 is intentionally not defined for a fast label. */
14680 
14681 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14682 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14683 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14684 
14685 #else
14686   /* Define argument-access macros assuming that fast branches are disabled. */
14687     /* The 0th argument is a nonresidual literal. */
14688 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
14689 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14690 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14691 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14692 #   define JITTER_ARGF0 JITTER_ARGP0
14693 
14694 #if defined(JITTER_DISPATCH_NO_THREADING)
14695 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
14696     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
14697 #elif defined (JITTER_REPLICATE)
14698 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
14699 #else
14700 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
14701 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
14702 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14703 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14704 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14705 #   define JITTER_ARGF1 JITTER_ARGP1
14706 
14707 # endif // #ifdef JITTER_HAVE_PATCH_IN
14708 
14709 #if defined (JITTER_PROFILE_SAMPLE)
14710   JITTER_PROFILE_SAMPLE_UPDATE
14711      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14712       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14713   /* Force the compiler not move sample-profiling instrumentation
14714      beyond this point; this way the actual user code is timed.
14715      This is still not perfect, as residuals are materialised before
14716      we arrive here, but should be adequate at least for slow VM
14717      instructions. */
14718   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14719 #endif
14720 #if defined (JITTER_PROFILE_COUNT)
14721   /* Notice that, differently from the code above, this
14722      instrumentation code *can* be reordered freely: as long as a
14723      VM instruction is counted, the count increment can be placed
14724      anyehere.  Let GCC move this code and possibly achieve better
14725      throughput by exploiting instruction-level parallelism and
14726      therefore approximate more closely a non-profiled build. */
14727   JITTER_PROFILE_COUNT_UPDATE
14728      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14729       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14730 #endif
14731 
14732 /* User-specified code, instruction-beginning-c part: beginning. */
14733 
14734 
14735 /* User-specified code, instruction-beginning-c part: end */
14736 
14737 
14738     /* User code for check-in-arity--alt/n0/fR . */
14739 
14740     // FIXME: this loops forever with no-threading (not with the other dispatching models
14741     // including minimal threading) when the callee is compiled.  A Jitter bug.
14742     /* Here we can assume that the top object is a closure, without checking: we either
14743        already performed a type check, or the compiler decided it wasn't necessary. */
14744     jitterlisp_object top = JITTER_TOP_MAINSTACK();
14745     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
14746 
14747     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
14748        from the closure compiledness.  [Done] */
14749     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
14750       {
14751         if (c->in_arity != JITTER_ARGN0)
14752           JITTER_BRANCH_FAST(JITTER_ARGF1);
14753       }
14754     else
14755       {
14756         /* The closure is interpreted.  Compute its in-arity.  We can assume that
14757            the formal list is well-formal, which is to say actually a proper list
14758            of distinct symbols. */
14759         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
14760         jitterlisp_object rest = ic->formals;
14761         jitter_uint in_arity = 0;
14762         while (! JITTERLISP_IS_EMPTY_LIST(rest))
14763           {
14764             in_arity ++;
14765             rest = JITTERLISP_EXP_C_A_CDR(rest);
14766           }
14767         if (in_arity != JITTER_ARGN0)
14768           JITTER_BRANCH_FAST(JITTER_ARGF1);
14769       }
14770 
14771     /* End of the user code for check-in-arity--alt/n0/fR . */
14772 
14773 /* User-specified code, instruction-end-c part: beginning. */
14774 
14775 
14776 /* User-specified code, instruction-end-c part: end */
14777 
14778     /* Undefine the check-in-arity--alt/n0/fR argument macros so they can't be used
14779        by mistake in the instruction body coming next. */
14780 #   undef JITTER_SLOW_REGISTER_OFFSET0
14781 #   undef JITTER_ARG0
14782 #   undef JITTER_ARGN0
14783 #   undef JITTER_ARGU0
14784 #   undef JITTER_ARGP0
14785 #   undef JITTER_ARGF0
14786 #   undef JITTER_SLOW_REGISTER_OFFSET1
14787 #   undef JITTER_ARG1
14788 #   undef JITTER_ARGN1
14789 #   undef JITTER_ARGU1
14790 #   undef JITTER_ARGP1
14791 #   undef JITTER_ARGF1
14792 
14793 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
14794 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
14795 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
14796 
14797   }
14798  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n0/fR, check_min_marity_m_malt__n0__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
14799 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
14800 
14801   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n1/fR, check_min_marity_m_malt__n1__fR, hot)
14802   {
14803     /* This specialized instruction is not a replacement. */
14804 #   undef JITTER_BRANCH_FAST
14805 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
14806 #   undef JITTER_BRANCH_FAST_IF_ZERO
14807 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
14808 #   undef JITTER_BRANCH_FAST_IF_NONZERO
14809 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
14810 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
14811 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
14812 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
14813 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
14814 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
14815 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
14816 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
14817 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
14818 #   undef JITTER_BRANCH_FAST_IF_EQUAL
14819 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
14820 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
14821 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
14822 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
14823 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
14824 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14825 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
14826 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14827 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
14828 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14829 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
14830 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14831 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
14832 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14833 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
14834 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14835 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
14836 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14837 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
14838 #   undef JITTER_BRANCH_FAST_IF_AND
14839 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
14840 #   undef JITTER_BRANCH_FAST_IF_NOTAND
14841 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
14842 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14843 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
14844 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14845 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
14846 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14847 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
14848 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14849 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
14850 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14851 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
14852 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14853 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
14854 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14855 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
14856 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14857 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
14858 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14859 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
14860 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14861 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
14862 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14863 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
14864 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14865 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
14866 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14867 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
14868 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       67
14869 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n1/fR
14870 
14871 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n1__fR
14872 
14873   /* The residual arity varies depending on whether we have fast labels. */
14874 #ifdef JITTER_HAVE_PATCH_IN
14875   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
14876 #else
14877   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
14878 #endif // #ifdef JITTER_HAVE_PATCH_IN
14879 
14880   /* Define argument-access macros for check-in-arity--alt/n1/fR . */
14881 #ifdef JITTER_HAVE_PATCH_IN
14882   /* Define argument-access macros assuming that fast branches are enabled. */
14883     /* The 0th argument is a nonresidual literal. */
14884 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
14885 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14886 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14887 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14888 
14889     /* The 1th argument is a "residual" fast label.  Define its
14890        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
14891        so that at replication time we know what instruction address to patch in. */
14892 #   define JITTER_ARGF1 0
14893     /* JITTER_ARG1 is intentionally not defined for a fast label. */
14894 
14895 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14896 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14897 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14898 
14899 #else
14900   /* Define argument-access macros assuming that fast branches are disabled. */
14901     /* The 0th argument is a nonresidual literal. */
14902 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
14903 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
14904 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
14905 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
14906 #   define JITTER_ARGF0 JITTER_ARGP0
14907 
14908 #if defined(JITTER_DISPATCH_NO_THREADING)
14909 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
14910     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
14911 #elif defined (JITTER_REPLICATE)
14912 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
14913 #else
14914 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
14915 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
14916 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
14917 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
14918 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
14919 #   define JITTER_ARGF1 JITTER_ARGP1
14920 
14921 # endif // #ifdef JITTER_HAVE_PATCH_IN
14922 
14923 #if defined (JITTER_PROFILE_SAMPLE)
14924   JITTER_PROFILE_SAMPLE_UPDATE
14925      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14926       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14927   /* Force the compiler not move sample-profiling instrumentation
14928      beyond this point; this way the actual user code is timed.
14929      This is still not perfect, as residuals are materialised before
14930      we arrive here, but should be adequate at least for slow VM
14931      instructions. */
14932   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
14933 #endif
14934 #if defined (JITTER_PROFILE_COUNT)
14935   /* Notice that, differently from the code above, this
14936      instrumentation code *can* be reordered freely: as long as a
14937      VM instruction is counted, the count increment can be placed
14938      anyehere.  Let GCC move this code and possibly achieve better
14939      throughput by exploiting instruction-level parallelism and
14940      therefore approximate more closely a non-profiled build. */
14941   JITTER_PROFILE_COUNT_UPDATE
14942      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
14943       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
14944 #endif
14945 
14946 /* User-specified code, instruction-beginning-c part: beginning. */
14947 
14948 
14949 /* User-specified code, instruction-beginning-c part: end */
14950 
14951 
14952     /* User code for check-in-arity--alt/n1/fR . */
14953 
14954     // FIXME: this loops forever with no-threading (not with the other dispatching models
14955     // including minimal threading) when the callee is compiled.  A Jitter bug.
14956     /* Here we can assume that the top object is a closure, without checking: we either
14957        already performed a type check, or the compiler decided it wasn't necessary. */
14958     jitterlisp_object top = JITTER_TOP_MAINSTACK();
14959     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
14960 
14961     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
14962        from the closure compiledness.  [Done] */
14963     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
14964       {
14965         if (c->in_arity != JITTER_ARGN0)
14966           JITTER_BRANCH_FAST(JITTER_ARGF1);
14967       }
14968     else
14969       {
14970         /* The closure is interpreted.  Compute its in-arity.  We can assume that
14971            the formal list is well-formal, which is to say actually a proper list
14972            of distinct symbols. */
14973         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
14974         jitterlisp_object rest = ic->formals;
14975         jitter_uint in_arity = 0;
14976         while (! JITTERLISP_IS_EMPTY_LIST(rest))
14977           {
14978             in_arity ++;
14979             rest = JITTERLISP_EXP_C_A_CDR(rest);
14980           }
14981         if (in_arity != JITTER_ARGN0)
14982           JITTER_BRANCH_FAST(JITTER_ARGF1);
14983       }
14984 
14985     /* End of the user code for check-in-arity--alt/n1/fR . */
14986 
14987 /* User-specified code, instruction-end-c part: beginning. */
14988 
14989 
14990 /* User-specified code, instruction-end-c part: end */
14991 
14992     /* Undefine the check-in-arity--alt/n1/fR argument macros so they can't be used
14993        by mistake in the instruction body coming next. */
14994 #   undef JITTER_SLOW_REGISTER_OFFSET0
14995 #   undef JITTER_ARG0
14996 #   undef JITTER_ARGN0
14997 #   undef JITTER_ARGU0
14998 #   undef JITTER_ARGP0
14999 #   undef JITTER_ARGF0
15000 #   undef JITTER_SLOW_REGISTER_OFFSET1
15001 #   undef JITTER_ARG1
15002 #   undef JITTER_ARGN1
15003 #   undef JITTER_ARGU1
15004 #   undef JITTER_ARGP1
15005 #   undef JITTER_ARGF1
15006 
15007 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15008 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15009 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15010 
15011   }
15012  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n1/fR, check_min_marity_m_malt__n1__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15013 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15014 
15015   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n2/fR, check_min_marity_m_malt__n2__fR, hot)
15016   {
15017     /* This specialized instruction is not a replacement. */
15018 #   undef JITTER_BRANCH_FAST
15019 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15020 #   undef JITTER_BRANCH_FAST_IF_ZERO
15021 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15022 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15023 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15024 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15025 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15026 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15027 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15028 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15029 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15030 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15031 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15032 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15033 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15034 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15035 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15036 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15037 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15038 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15039 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15040 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15041 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15042 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15043 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15044 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15045 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15046 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15047 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15048 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15049 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15050 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15051 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15052 #   undef JITTER_BRANCH_FAST_IF_AND
15053 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15054 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15055 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15056 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15057 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15058 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15059 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15060 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15061 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15062 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15063 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15064 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15065 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15066 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15067 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15068 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15069 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15070 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15071 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15072 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15073 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15074 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15075 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15076 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15077 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15078 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15079 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15080 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15081 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15082 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       68
15083 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n2/fR
15084 
15085 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n2__fR
15086 
15087   /* The residual arity varies depending on whether we have fast labels. */
15088 #ifdef JITTER_HAVE_PATCH_IN
15089   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15090 #else
15091   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15092 #endif // #ifdef JITTER_HAVE_PATCH_IN
15093 
15094   /* Define argument-access macros for check-in-arity--alt/n2/fR . */
15095 #ifdef JITTER_HAVE_PATCH_IN
15096   /* Define argument-access macros assuming that fast branches are enabled. */
15097     /* The 0th argument is a nonresidual literal. */
15098 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
15099 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15100 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15101 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15102 
15103     /* The 1th argument is a "residual" fast label.  Define its
15104        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
15105        so that at replication time we know what instruction address to patch in. */
15106 #   define JITTER_ARGF1 0
15107     /* JITTER_ARG1 is intentionally not defined for a fast label. */
15108 
15109 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15110 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15111 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15112 
15113 #else
15114   /* Define argument-access macros assuming that fast branches are disabled. */
15115     /* The 0th argument is a nonresidual literal. */
15116 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
15117 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15118 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15119 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15120 #   define JITTER_ARGF0 JITTER_ARGP0
15121 
15122 #if defined(JITTER_DISPATCH_NO_THREADING)
15123 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
15124     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15125 #elif defined (JITTER_REPLICATE)
15126 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
15127 #else
15128 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
15129 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15130 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15131 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15132 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15133 #   define JITTER_ARGF1 JITTER_ARGP1
15134 
15135 # endif // #ifdef JITTER_HAVE_PATCH_IN
15136 
15137 #if defined (JITTER_PROFILE_SAMPLE)
15138   JITTER_PROFILE_SAMPLE_UPDATE
15139      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15140       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15141   /* Force the compiler not move sample-profiling instrumentation
15142      beyond this point; this way the actual user code is timed.
15143      This is still not perfect, as residuals are materialised before
15144      we arrive here, but should be adequate at least for slow VM
15145      instructions. */
15146   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15147 #endif
15148 #if defined (JITTER_PROFILE_COUNT)
15149   /* Notice that, differently from the code above, this
15150      instrumentation code *can* be reordered freely: as long as a
15151      VM instruction is counted, the count increment can be placed
15152      anyehere.  Let GCC move this code and possibly achieve better
15153      throughput by exploiting instruction-level parallelism and
15154      therefore approximate more closely a non-profiled build. */
15155   JITTER_PROFILE_COUNT_UPDATE
15156      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15157       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15158 #endif
15159 
15160 /* User-specified code, instruction-beginning-c part: beginning. */
15161 
15162 
15163 /* User-specified code, instruction-beginning-c part: end */
15164 
15165 
15166     /* User code for check-in-arity--alt/n2/fR . */
15167 
15168     // FIXME: this loops forever with no-threading (not with the other dispatching models
15169     // including minimal threading) when the callee is compiled.  A Jitter bug.
15170     /* Here we can assume that the top object is a closure, without checking: we either
15171        already performed a type check, or the compiler decided it wasn't necessary. */
15172     jitterlisp_object top = JITTER_TOP_MAINSTACK();
15173     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
15174 
15175     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
15176        from the closure compiledness.  [Done] */
15177     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
15178       {
15179         if (c->in_arity != JITTER_ARGN0)
15180           JITTER_BRANCH_FAST(JITTER_ARGF1);
15181       }
15182     else
15183       {
15184         /* The closure is interpreted.  Compute its in-arity.  We can assume that
15185            the formal list is well-formal, which is to say actually a proper list
15186            of distinct symbols. */
15187         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
15188         jitterlisp_object rest = ic->formals;
15189         jitter_uint in_arity = 0;
15190         while (! JITTERLISP_IS_EMPTY_LIST(rest))
15191           {
15192             in_arity ++;
15193             rest = JITTERLISP_EXP_C_A_CDR(rest);
15194           }
15195         if (in_arity != JITTER_ARGN0)
15196           JITTER_BRANCH_FAST(JITTER_ARGF1);
15197       }
15198 
15199     /* End of the user code for check-in-arity--alt/n2/fR . */
15200 
15201 /* User-specified code, instruction-end-c part: beginning. */
15202 
15203 
15204 /* User-specified code, instruction-end-c part: end */
15205 
15206     /* Undefine the check-in-arity--alt/n2/fR argument macros so they can't be used
15207        by mistake in the instruction body coming next. */
15208 #   undef JITTER_SLOW_REGISTER_OFFSET0
15209 #   undef JITTER_ARG0
15210 #   undef JITTER_ARGN0
15211 #   undef JITTER_ARGU0
15212 #   undef JITTER_ARGP0
15213 #   undef JITTER_ARGF0
15214 #   undef JITTER_SLOW_REGISTER_OFFSET1
15215 #   undef JITTER_ARG1
15216 #   undef JITTER_ARGN1
15217 #   undef JITTER_ARGU1
15218 #   undef JITTER_ARGP1
15219 #   undef JITTER_ARGF1
15220 
15221 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15222 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15223 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15224 
15225   }
15226  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n2/fR, check_min_marity_m_malt__n2__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15227 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15228 
15229   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n3/fR, check_min_marity_m_malt__n3__fR, hot)
15230   {
15231     /* This specialized instruction is not a replacement. */
15232 #   undef JITTER_BRANCH_FAST
15233 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15234 #   undef JITTER_BRANCH_FAST_IF_ZERO
15235 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15236 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15237 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15238 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15239 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15240 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15241 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15242 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15243 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15244 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15245 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15246 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15247 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15248 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15249 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15250 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15251 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15252 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15253 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15254 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15255 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15256 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15257 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15258 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15259 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15260 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15261 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15262 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15263 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15264 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15265 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15266 #   undef JITTER_BRANCH_FAST_IF_AND
15267 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15268 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15269 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15270 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15271 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15272 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15273 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15274 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15275 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15276 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15277 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15278 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15279 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15280 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15281 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15282 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15283 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15284 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15285 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15286 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15287 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15288 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15289 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15290 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15291 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15292 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15293 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15294 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15295 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15296 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       69
15297 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n3/fR
15298 
15299 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n3__fR
15300 
15301   /* The residual arity varies depending on whether we have fast labels. */
15302 #ifdef JITTER_HAVE_PATCH_IN
15303   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15304 #else
15305   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15306 #endif // #ifdef JITTER_HAVE_PATCH_IN
15307 
15308   /* Define argument-access macros for check-in-arity--alt/n3/fR . */
15309 #ifdef JITTER_HAVE_PATCH_IN
15310   /* Define argument-access macros assuming that fast branches are enabled. */
15311     /* The 0th argument is a nonresidual literal. */
15312 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
15313 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15314 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15315 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15316 
15317     /* The 1th argument is a "residual" fast label.  Define its
15318        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
15319        so that at replication time we know what instruction address to patch in. */
15320 #   define JITTER_ARGF1 0
15321     /* JITTER_ARG1 is intentionally not defined for a fast label. */
15322 
15323 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15324 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15325 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15326 
15327 #else
15328   /* Define argument-access macros assuming that fast branches are disabled. */
15329     /* The 0th argument is a nonresidual literal. */
15330 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
15331 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15332 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15333 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15334 #   define JITTER_ARGF0 JITTER_ARGP0
15335 
15336 #if defined(JITTER_DISPATCH_NO_THREADING)
15337 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
15338     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15339 #elif defined (JITTER_REPLICATE)
15340 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
15341 #else
15342 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
15343 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15344 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15345 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15346 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15347 #   define JITTER_ARGF1 JITTER_ARGP1
15348 
15349 # endif // #ifdef JITTER_HAVE_PATCH_IN
15350 
15351 #if defined (JITTER_PROFILE_SAMPLE)
15352   JITTER_PROFILE_SAMPLE_UPDATE
15353      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15354       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15355   /* Force the compiler not move sample-profiling instrumentation
15356      beyond this point; this way the actual user code is timed.
15357      This is still not perfect, as residuals are materialised before
15358      we arrive here, but should be adequate at least for slow VM
15359      instructions. */
15360   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15361 #endif
15362 #if defined (JITTER_PROFILE_COUNT)
15363   /* Notice that, differently from the code above, this
15364      instrumentation code *can* be reordered freely: as long as a
15365      VM instruction is counted, the count increment can be placed
15366      anyehere.  Let GCC move this code and possibly achieve better
15367      throughput by exploiting instruction-level parallelism and
15368      therefore approximate more closely a non-profiled build. */
15369   JITTER_PROFILE_COUNT_UPDATE
15370      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15371       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15372 #endif
15373 
15374 /* User-specified code, instruction-beginning-c part: beginning. */
15375 
15376 
15377 /* User-specified code, instruction-beginning-c part: end */
15378 
15379 
15380     /* User code for check-in-arity--alt/n3/fR . */
15381 
15382     // FIXME: this loops forever with no-threading (not with the other dispatching models
15383     // including minimal threading) when the callee is compiled.  A Jitter bug.
15384     /* Here we can assume that the top object is a closure, without checking: we either
15385        already performed a type check, or the compiler decided it wasn't necessary. */
15386     jitterlisp_object top = JITTER_TOP_MAINSTACK();
15387     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
15388 
15389     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
15390        from the closure compiledness.  [Done] */
15391     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
15392       {
15393         if (c->in_arity != JITTER_ARGN0)
15394           JITTER_BRANCH_FAST(JITTER_ARGF1);
15395       }
15396     else
15397       {
15398         /* The closure is interpreted.  Compute its in-arity.  We can assume that
15399            the formal list is well-formal, which is to say actually a proper list
15400            of distinct symbols. */
15401         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
15402         jitterlisp_object rest = ic->formals;
15403         jitter_uint in_arity = 0;
15404         while (! JITTERLISP_IS_EMPTY_LIST(rest))
15405           {
15406             in_arity ++;
15407             rest = JITTERLISP_EXP_C_A_CDR(rest);
15408           }
15409         if (in_arity != JITTER_ARGN0)
15410           JITTER_BRANCH_FAST(JITTER_ARGF1);
15411       }
15412 
15413     /* End of the user code for check-in-arity--alt/n3/fR . */
15414 
15415 /* User-specified code, instruction-end-c part: beginning. */
15416 
15417 
15418 /* User-specified code, instruction-end-c part: end */
15419 
15420     /* Undefine the check-in-arity--alt/n3/fR argument macros so they can't be used
15421        by mistake in the instruction body coming next. */
15422 #   undef JITTER_SLOW_REGISTER_OFFSET0
15423 #   undef JITTER_ARG0
15424 #   undef JITTER_ARGN0
15425 #   undef JITTER_ARGU0
15426 #   undef JITTER_ARGP0
15427 #   undef JITTER_ARGF0
15428 #   undef JITTER_SLOW_REGISTER_OFFSET1
15429 #   undef JITTER_ARG1
15430 #   undef JITTER_ARGN1
15431 #   undef JITTER_ARGU1
15432 #   undef JITTER_ARGP1
15433 #   undef JITTER_ARGF1
15434 
15435 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15436 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15437 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15438 
15439   }
15440  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n3/fR, check_min_marity_m_malt__n3__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15441 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15442 
15443   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n4/fR, check_min_marity_m_malt__n4__fR, hot)
15444   {
15445     /* This specialized instruction is not a replacement. */
15446 #   undef JITTER_BRANCH_FAST
15447 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15448 #   undef JITTER_BRANCH_FAST_IF_ZERO
15449 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15450 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15451 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15452 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15453 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15454 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15455 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15456 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15457 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15458 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15459 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15460 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15461 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15462 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15463 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15464 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15465 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15466 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15467 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15468 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15469 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15470 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15471 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15472 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15473 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15474 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15475 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15476 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15477 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15478 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15479 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15480 #   undef JITTER_BRANCH_FAST_IF_AND
15481 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15482 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15483 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15484 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15485 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15486 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15487 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15488 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15489 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15490 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15491 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15492 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15493 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15494 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15495 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15496 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15497 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15498 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15499 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15500 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15501 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15502 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15503 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15504 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15505 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15506 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15507 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15508 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15509 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15510 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       70
15511 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n4/fR
15512 
15513 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n4__fR
15514 
15515   /* The residual arity varies depending on whether we have fast labels. */
15516 #ifdef JITTER_HAVE_PATCH_IN
15517   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15518 #else
15519   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15520 #endif // #ifdef JITTER_HAVE_PATCH_IN
15521 
15522   /* Define argument-access macros for check-in-arity--alt/n4/fR . */
15523 #ifdef JITTER_HAVE_PATCH_IN
15524   /* Define argument-access macros assuming that fast branches are enabled. */
15525     /* The 0th argument is a nonresidual literal. */
15526 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
15527 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15528 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15529 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15530 
15531     /* The 1th argument is a "residual" fast label.  Define its
15532        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
15533        so that at replication time we know what instruction address to patch in. */
15534 #   define JITTER_ARGF1 0
15535     /* JITTER_ARG1 is intentionally not defined for a fast label. */
15536 
15537 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15538 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15539 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15540 
15541 #else
15542   /* Define argument-access macros assuming that fast branches are disabled. */
15543     /* The 0th argument is a nonresidual literal. */
15544 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
15545 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15546 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15547 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15548 #   define JITTER_ARGF0 JITTER_ARGP0
15549 
15550 #if defined(JITTER_DISPATCH_NO_THREADING)
15551 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
15552     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15553 #elif defined (JITTER_REPLICATE)
15554 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
15555 #else
15556 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
15557 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15558 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15559 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15560 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15561 #   define JITTER_ARGF1 JITTER_ARGP1
15562 
15563 # endif // #ifdef JITTER_HAVE_PATCH_IN
15564 
15565 #if defined (JITTER_PROFILE_SAMPLE)
15566   JITTER_PROFILE_SAMPLE_UPDATE
15567      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15568       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15569   /* Force the compiler not move sample-profiling instrumentation
15570      beyond this point; this way the actual user code is timed.
15571      This is still not perfect, as residuals are materialised before
15572      we arrive here, but should be adequate at least for slow VM
15573      instructions. */
15574   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15575 #endif
15576 #if defined (JITTER_PROFILE_COUNT)
15577   /* Notice that, differently from the code above, this
15578      instrumentation code *can* be reordered freely: as long as a
15579      VM instruction is counted, the count increment can be placed
15580      anyehere.  Let GCC move this code and possibly achieve better
15581      throughput by exploiting instruction-level parallelism and
15582      therefore approximate more closely a non-profiled build. */
15583   JITTER_PROFILE_COUNT_UPDATE
15584      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15585       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15586 #endif
15587 
15588 /* User-specified code, instruction-beginning-c part: beginning. */
15589 
15590 
15591 /* User-specified code, instruction-beginning-c part: end */
15592 
15593 
15594     /* User code for check-in-arity--alt/n4/fR . */
15595 
15596     // FIXME: this loops forever with no-threading (not with the other dispatching models
15597     // including minimal threading) when the callee is compiled.  A Jitter bug.
15598     /* Here we can assume that the top object is a closure, without checking: we either
15599        already performed a type check, or the compiler decided it wasn't necessary. */
15600     jitterlisp_object top = JITTER_TOP_MAINSTACK();
15601     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
15602 
15603     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
15604        from the closure compiledness.  [Done] */
15605     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
15606       {
15607         if (c->in_arity != JITTER_ARGN0)
15608           JITTER_BRANCH_FAST(JITTER_ARGF1);
15609       }
15610     else
15611       {
15612         /* The closure is interpreted.  Compute its in-arity.  We can assume that
15613            the formal list is well-formal, which is to say actually a proper list
15614            of distinct symbols. */
15615         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
15616         jitterlisp_object rest = ic->formals;
15617         jitter_uint in_arity = 0;
15618         while (! JITTERLISP_IS_EMPTY_LIST(rest))
15619           {
15620             in_arity ++;
15621             rest = JITTERLISP_EXP_C_A_CDR(rest);
15622           }
15623         if (in_arity != JITTER_ARGN0)
15624           JITTER_BRANCH_FAST(JITTER_ARGF1);
15625       }
15626 
15627     /* End of the user code for check-in-arity--alt/n4/fR . */
15628 
15629 /* User-specified code, instruction-end-c part: beginning. */
15630 
15631 
15632 /* User-specified code, instruction-end-c part: end */
15633 
15634     /* Undefine the check-in-arity--alt/n4/fR argument macros so they can't be used
15635        by mistake in the instruction body coming next. */
15636 #   undef JITTER_SLOW_REGISTER_OFFSET0
15637 #   undef JITTER_ARG0
15638 #   undef JITTER_ARGN0
15639 #   undef JITTER_ARGU0
15640 #   undef JITTER_ARGP0
15641 #   undef JITTER_ARGF0
15642 #   undef JITTER_SLOW_REGISTER_OFFSET1
15643 #   undef JITTER_ARG1
15644 #   undef JITTER_ARGN1
15645 #   undef JITTER_ARGU1
15646 #   undef JITTER_ARGP1
15647 #   undef JITTER_ARGF1
15648 
15649 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15650 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15651 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15652 
15653   }
15654  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n4/fR, check_min_marity_m_malt__n4__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15655 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15656 
15657   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n5/fR, check_min_marity_m_malt__n5__fR, hot)
15658   {
15659     /* This specialized instruction is not a replacement. */
15660 #   undef JITTER_BRANCH_FAST
15661 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15662 #   undef JITTER_BRANCH_FAST_IF_ZERO
15663 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15664 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15665 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15666 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15667 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15668 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15669 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15670 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15671 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15672 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15673 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15674 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15675 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15676 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15677 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15678 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15679 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15680 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15681 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15682 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15683 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15684 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15685 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15686 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15687 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15688 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15689 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15690 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15691 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15692 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15693 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15694 #   undef JITTER_BRANCH_FAST_IF_AND
15695 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15696 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15697 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15698 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15699 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15700 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15701 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15702 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15703 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15704 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15705 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15706 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15707 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15708 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15709 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15710 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15711 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15712 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15713 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15714 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15715 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15716 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15717 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15718 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15719 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15720 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15721 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15722 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15723 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15724 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       71
15725 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n5/fR
15726 
15727 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n5__fR
15728 
15729   /* The residual arity varies depending on whether we have fast labels. */
15730 #ifdef JITTER_HAVE_PATCH_IN
15731   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15732 #else
15733   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15734 #endif // #ifdef JITTER_HAVE_PATCH_IN
15735 
15736   /* Define argument-access macros for check-in-arity--alt/n5/fR . */
15737 #ifdef JITTER_HAVE_PATCH_IN
15738   /* Define argument-access macros assuming that fast branches are enabled. */
15739     /* The 0th argument is a nonresidual literal. */
15740 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
15741 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15742 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15743 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15744 
15745     /* The 1th argument is a "residual" fast label.  Define its
15746        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
15747        so that at replication time we know what instruction address to patch in. */
15748 #   define JITTER_ARGF1 0
15749     /* JITTER_ARG1 is intentionally not defined for a fast label. */
15750 
15751 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15752 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15753 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15754 
15755 #else
15756   /* Define argument-access macros assuming that fast branches are disabled. */
15757     /* The 0th argument is a nonresidual literal. */
15758 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
15759 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15760 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15761 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15762 #   define JITTER_ARGF0 JITTER_ARGP0
15763 
15764 #if defined(JITTER_DISPATCH_NO_THREADING)
15765 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
15766     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15767 #elif defined (JITTER_REPLICATE)
15768 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
15769 #else
15770 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
15771 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15772 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15773 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15774 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15775 #   define JITTER_ARGF1 JITTER_ARGP1
15776 
15777 # endif // #ifdef JITTER_HAVE_PATCH_IN
15778 
15779 #if defined (JITTER_PROFILE_SAMPLE)
15780   JITTER_PROFILE_SAMPLE_UPDATE
15781      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15782       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15783   /* Force the compiler not move sample-profiling instrumentation
15784      beyond this point; this way the actual user code is timed.
15785      This is still not perfect, as residuals are materialised before
15786      we arrive here, but should be adequate at least for slow VM
15787      instructions. */
15788   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
15789 #endif
15790 #if defined (JITTER_PROFILE_COUNT)
15791   /* Notice that, differently from the code above, this
15792      instrumentation code *can* be reordered freely: as long as a
15793      VM instruction is counted, the count increment can be placed
15794      anyehere.  Let GCC move this code and possibly achieve better
15795      throughput by exploiting instruction-level parallelism and
15796      therefore approximate more closely a non-profiled build. */
15797   JITTER_PROFILE_COUNT_UPDATE
15798      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15799       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15800 #endif
15801 
15802 /* User-specified code, instruction-beginning-c part: beginning. */
15803 
15804 
15805 /* User-specified code, instruction-beginning-c part: end */
15806 
15807 
15808     /* User code for check-in-arity--alt/n5/fR . */
15809 
15810     // FIXME: this loops forever with no-threading (not with the other dispatching models
15811     // including minimal threading) when the callee is compiled.  A Jitter bug.
15812     /* Here we can assume that the top object is a closure, without checking: we either
15813        already performed a type check, or the compiler decided it wasn't necessary. */
15814     jitterlisp_object top = JITTER_TOP_MAINSTACK();
15815     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
15816 
15817     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
15818        from the closure compiledness.  [Done] */
15819     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
15820       {
15821         if (c->in_arity != JITTER_ARGN0)
15822           JITTER_BRANCH_FAST(JITTER_ARGF1);
15823       }
15824     else
15825       {
15826         /* The closure is interpreted.  Compute its in-arity.  We can assume that
15827            the formal list is well-formal, which is to say actually a proper list
15828            of distinct symbols. */
15829         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
15830         jitterlisp_object rest = ic->formals;
15831         jitter_uint in_arity = 0;
15832         while (! JITTERLISP_IS_EMPTY_LIST(rest))
15833           {
15834             in_arity ++;
15835             rest = JITTERLISP_EXP_C_A_CDR(rest);
15836           }
15837         if (in_arity != JITTER_ARGN0)
15838           JITTER_BRANCH_FAST(JITTER_ARGF1);
15839       }
15840 
15841     /* End of the user code for check-in-arity--alt/n5/fR . */
15842 
15843 /* User-specified code, instruction-end-c part: beginning. */
15844 
15845 
15846 /* User-specified code, instruction-end-c part: end */
15847 
15848     /* Undefine the check-in-arity--alt/n5/fR argument macros so they can't be used
15849        by mistake in the instruction body coming next. */
15850 #   undef JITTER_SLOW_REGISTER_OFFSET0
15851 #   undef JITTER_ARG0
15852 #   undef JITTER_ARGN0
15853 #   undef JITTER_ARGU0
15854 #   undef JITTER_ARGP0
15855 #   undef JITTER_ARGF0
15856 #   undef JITTER_SLOW_REGISTER_OFFSET1
15857 #   undef JITTER_ARG1
15858 #   undef JITTER_ARGN1
15859 #   undef JITTER_ARGU1
15860 #   undef JITTER_ARGP1
15861 #   undef JITTER_ARGF1
15862 
15863 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
15864 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
15865 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
15866 
15867   }
15868  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n5/fR, check_min_marity_m_malt__n5__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
15869 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
15870 
15871   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n6/fR, check_min_marity_m_malt__n6__fR, hot)
15872   {
15873     /* This specialized instruction is not a replacement. */
15874 #   undef JITTER_BRANCH_FAST
15875 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
15876 #   undef JITTER_BRANCH_FAST_IF_ZERO
15877 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
15878 #   undef JITTER_BRANCH_FAST_IF_NONZERO
15879 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
15880 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
15881 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
15882 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
15883 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
15884 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
15885 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
15886 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
15887 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
15888 #   undef JITTER_BRANCH_FAST_IF_EQUAL
15889 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
15890 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
15891 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
15892 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
15893 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
15894 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15895 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
15896 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15897 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
15898 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15899 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
15900 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15901 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
15902 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15903 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
15904 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15905 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
15906 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15907 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
15908 #   undef JITTER_BRANCH_FAST_IF_AND
15909 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
15910 #   undef JITTER_BRANCH_FAST_IF_NOTAND
15911 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
15912 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15913 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
15914 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15915 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
15916 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15917 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
15918 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15919 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
15920 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15921 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
15922 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15923 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
15924 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15925 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
15926 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15927 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
15928 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15929 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
15930 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15931 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
15932 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15933 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
15934 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15935 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
15936 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15937 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
15938 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       72
15939 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n6/fR
15940 
15941 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n6__fR
15942 
15943   /* The residual arity varies depending on whether we have fast labels. */
15944 #ifdef JITTER_HAVE_PATCH_IN
15945   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
15946 #else
15947   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
15948 #endif // #ifdef JITTER_HAVE_PATCH_IN
15949 
15950   /* Define argument-access macros for check-in-arity--alt/n6/fR . */
15951 #ifdef JITTER_HAVE_PATCH_IN
15952   /* Define argument-access macros assuming that fast branches are enabled. */
15953     /* The 0th argument is a nonresidual literal. */
15954 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
15955 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15956 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15957 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15958 
15959     /* The 1th argument is a "residual" fast label.  Define its
15960        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
15961        so that at replication time we know what instruction address to patch in. */
15962 #   define JITTER_ARGF1 0
15963     /* JITTER_ARG1 is intentionally not defined for a fast label. */
15964 
15965 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15966 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15967 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15968 
15969 #else
15970   /* Define argument-access macros assuming that fast branches are disabled. */
15971     /* The 0th argument is a nonresidual literal. */
15972 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
15973 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
15974 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
15975 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
15976 #   define JITTER_ARGF0 JITTER_ARGP0
15977 
15978 #if defined(JITTER_DISPATCH_NO_THREADING)
15979 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
15980     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
15981 #elif defined (JITTER_REPLICATE)
15982 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
15983 #else
15984 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
15985 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
15986 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
15987 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
15988 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
15989 #   define JITTER_ARGF1 JITTER_ARGP1
15990 
15991 # endif // #ifdef JITTER_HAVE_PATCH_IN
15992 
15993 #if defined (JITTER_PROFILE_SAMPLE)
15994   JITTER_PROFILE_SAMPLE_UPDATE
15995      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
15996       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
15997   /* Force the compiler not move sample-profiling instrumentation
15998      beyond this point; this way the actual user code is timed.
15999      This is still not perfect, as residuals are materialised before
16000      we arrive here, but should be adequate at least for slow VM
16001      instructions. */
16002   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16003 #endif
16004 #if defined (JITTER_PROFILE_COUNT)
16005   /* Notice that, differently from the code above, this
16006      instrumentation code *can* be reordered freely: as long as a
16007      VM instruction is counted, the count increment can be placed
16008      anyehere.  Let GCC move this code and possibly achieve better
16009      throughput by exploiting instruction-level parallelism and
16010      therefore approximate more closely a non-profiled build. */
16011   JITTER_PROFILE_COUNT_UPDATE
16012      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16013       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16014 #endif
16015 
16016 /* User-specified code, instruction-beginning-c part: beginning. */
16017 
16018 
16019 /* User-specified code, instruction-beginning-c part: end */
16020 
16021 
16022     /* User code for check-in-arity--alt/n6/fR . */
16023 
16024     // FIXME: this loops forever with no-threading (not with the other dispatching models
16025     // including minimal threading) when the callee is compiled.  A Jitter bug.
16026     /* Here we can assume that the top object is a closure, without checking: we either
16027        already performed a type check, or the compiler decided it wasn't necessary. */
16028     jitterlisp_object top = JITTER_TOP_MAINSTACK();
16029     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
16030 
16031     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
16032        from the closure compiledness.  [Done] */
16033     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
16034       {
16035         if (c->in_arity != JITTER_ARGN0)
16036           JITTER_BRANCH_FAST(JITTER_ARGF1);
16037       }
16038     else
16039       {
16040         /* The closure is interpreted.  Compute its in-arity.  We can assume that
16041            the formal list is well-formal, which is to say actually a proper list
16042            of distinct symbols. */
16043         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
16044         jitterlisp_object rest = ic->formals;
16045         jitter_uint in_arity = 0;
16046         while (! JITTERLISP_IS_EMPTY_LIST(rest))
16047           {
16048             in_arity ++;
16049             rest = JITTERLISP_EXP_C_A_CDR(rest);
16050           }
16051         if (in_arity != JITTER_ARGN0)
16052           JITTER_BRANCH_FAST(JITTER_ARGF1);
16053       }
16054 
16055     /* End of the user code for check-in-arity--alt/n6/fR . */
16056 
16057 /* User-specified code, instruction-end-c part: beginning. */
16058 
16059 
16060 /* User-specified code, instruction-end-c part: end */
16061 
16062     /* Undefine the check-in-arity--alt/n6/fR argument macros so they can't be used
16063        by mistake in the instruction body coming next. */
16064 #   undef JITTER_SLOW_REGISTER_OFFSET0
16065 #   undef JITTER_ARG0
16066 #   undef JITTER_ARGN0
16067 #   undef JITTER_ARGU0
16068 #   undef JITTER_ARGP0
16069 #   undef JITTER_ARGF0
16070 #   undef JITTER_SLOW_REGISTER_OFFSET1
16071 #   undef JITTER_ARG1
16072 #   undef JITTER_ARGN1
16073 #   undef JITTER_ARGU1
16074 #   undef JITTER_ARGP1
16075 #   undef JITTER_ARGF1
16076 
16077 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16078 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16079 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16080 
16081   }
16082  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n6/fR, check_min_marity_m_malt__n6__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16083 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16084 
16085   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n7/fR, check_min_marity_m_malt__n7__fR, hot)
16086   {
16087     /* This specialized instruction is not a replacement. */
16088 #   undef JITTER_BRANCH_FAST
16089 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16090 #   undef JITTER_BRANCH_FAST_IF_ZERO
16091 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16092 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16093 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16094 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16095 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16096 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16097 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16098 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16099 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16100 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16101 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16102 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16103 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16104 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16105 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16106 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16107 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16108 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16109 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16110 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16111 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16112 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16113 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16114 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16115 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16116 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16117 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16118 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16119 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16120 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16121 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16122 #   undef JITTER_BRANCH_FAST_IF_AND
16123 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16124 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16125 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16126 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16127 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16128 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16129 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16130 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16131 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16132 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16133 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16134 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16135 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16136 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16137 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16138 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16139 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16140 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16141 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16142 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16143 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16144 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16145 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16146 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16147 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16148 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16149 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16150 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16151 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16152 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       73
16153 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n7/fR
16154 
16155 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n7__fR
16156 
16157   /* The residual arity varies depending on whether we have fast labels. */
16158 #ifdef JITTER_HAVE_PATCH_IN
16159   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
16160 #else
16161   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16162 #endif // #ifdef JITTER_HAVE_PATCH_IN
16163 
16164   /* Define argument-access macros for check-in-arity--alt/n7/fR . */
16165 #ifdef JITTER_HAVE_PATCH_IN
16166   /* Define argument-access macros assuming that fast branches are enabled. */
16167     /* The 0th argument is a nonresidual literal. */
16168 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
16169 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16170 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16171 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16172 
16173     /* The 1th argument is a "residual" fast label.  Define its
16174        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
16175        so that at replication time we know what instruction address to patch in. */
16176 #   define JITTER_ARGF1 0
16177     /* JITTER_ARG1 is intentionally not defined for a fast label. */
16178 
16179 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16180 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16181 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16182 
16183 #else
16184   /* Define argument-access macros assuming that fast branches are disabled. */
16185     /* The 0th argument is a nonresidual literal. */
16186 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
16187 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16188 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16189 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16190 #   define JITTER_ARGF0 JITTER_ARGP0
16191 
16192 #if defined(JITTER_DISPATCH_NO_THREADING)
16193 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
16194     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16195 #elif defined (JITTER_REPLICATE)
16196 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
16197 #else
16198 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
16199 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16200 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16201 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16202 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16203 #   define JITTER_ARGF1 JITTER_ARGP1
16204 
16205 # endif // #ifdef JITTER_HAVE_PATCH_IN
16206 
16207 #if defined (JITTER_PROFILE_SAMPLE)
16208   JITTER_PROFILE_SAMPLE_UPDATE
16209      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16210       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16211   /* Force the compiler not move sample-profiling instrumentation
16212      beyond this point; this way the actual user code is timed.
16213      This is still not perfect, as residuals are materialised before
16214      we arrive here, but should be adequate at least for slow VM
16215      instructions. */
16216   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16217 #endif
16218 #if defined (JITTER_PROFILE_COUNT)
16219   /* Notice that, differently from the code above, this
16220      instrumentation code *can* be reordered freely: as long as a
16221      VM instruction is counted, the count increment can be placed
16222      anyehere.  Let GCC move this code and possibly achieve better
16223      throughput by exploiting instruction-level parallelism and
16224      therefore approximate more closely a non-profiled build. */
16225   JITTER_PROFILE_COUNT_UPDATE
16226      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16227       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16228 #endif
16229 
16230 /* User-specified code, instruction-beginning-c part: beginning. */
16231 
16232 
16233 /* User-specified code, instruction-beginning-c part: end */
16234 
16235 
16236     /* User code for check-in-arity--alt/n7/fR . */
16237 
16238     // FIXME: this loops forever with no-threading (not with the other dispatching models
16239     // including minimal threading) when the callee is compiled.  A Jitter bug.
16240     /* Here we can assume that the top object is a closure, without checking: we either
16241        already performed a type check, or the compiler decided it wasn't necessary. */
16242     jitterlisp_object top = JITTER_TOP_MAINSTACK();
16243     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
16244 
16245     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
16246        from the closure compiledness.  [Done] */
16247     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
16248       {
16249         if (c->in_arity != JITTER_ARGN0)
16250           JITTER_BRANCH_FAST(JITTER_ARGF1);
16251       }
16252     else
16253       {
16254         /* The closure is interpreted.  Compute its in-arity.  We can assume that
16255            the formal list is well-formal, which is to say actually a proper list
16256            of distinct symbols. */
16257         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
16258         jitterlisp_object rest = ic->formals;
16259         jitter_uint in_arity = 0;
16260         while (! JITTERLISP_IS_EMPTY_LIST(rest))
16261           {
16262             in_arity ++;
16263             rest = JITTERLISP_EXP_C_A_CDR(rest);
16264           }
16265         if (in_arity != JITTER_ARGN0)
16266           JITTER_BRANCH_FAST(JITTER_ARGF1);
16267       }
16268 
16269     /* End of the user code for check-in-arity--alt/n7/fR . */
16270 
16271 /* User-specified code, instruction-end-c part: beginning. */
16272 
16273 
16274 /* User-specified code, instruction-end-c part: end */
16275 
16276     /* Undefine the check-in-arity--alt/n7/fR argument macros so they can't be used
16277        by mistake in the instruction body coming next. */
16278 #   undef JITTER_SLOW_REGISTER_OFFSET0
16279 #   undef JITTER_ARG0
16280 #   undef JITTER_ARGN0
16281 #   undef JITTER_ARGU0
16282 #   undef JITTER_ARGP0
16283 #   undef JITTER_ARGF0
16284 #   undef JITTER_SLOW_REGISTER_OFFSET1
16285 #   undef JITTER_ARG1
16286 #   undef JITTER_ARGN1
16287 #   undef JITTER_ARGU1
16288 #   undef JITTER_ARGP1
16289 #   undef JITTER_ARGF1
16290 
16291 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16292 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16293 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16294 
16295   }
16296  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n7/fR, check_min_marity_m_malt__n7__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16297 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16298 
16299   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n8/fR, check_min_marity_m_malt__n8__fR, hot)
16300   {
16301     /* This specialized instruction is not a replacement. */
16302 #   undef JITTER_BRANCH_FAST
16303 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16304 #   undef JITTER_BRANCH_FAST_IF_ZERO
16305 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16306 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16307 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16308 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16309 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16310 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16311 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16312 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16313 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16314 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16315 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16316 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16317 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16318 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16319 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16320 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16321 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16322 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16323 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16324 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16325 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16326 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16327 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16328 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16329 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16330 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16331 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16332 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16333 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16334 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16335 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16336 #   undef JITTER_BRANCH_FAST_IF_AND
16337 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16338 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16339 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16340 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16341 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16342 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16343 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16344 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16345 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16346 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16347 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16348 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16349 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16350 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16351 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16352 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16353 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16354 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16355 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16356 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16357 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16358 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16359 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16360 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16361 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16362 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16363 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16364 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16365 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16366 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       74
16367 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n8/fR
16368 
16369 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n8__fR
16370 
16371   /* The residual arity varies depending on whether we have fast labels. */
16372 #ifdef JITTER_HAVE_PATCH_IN
16373   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
16374 #else
16375   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16376 #endif // #ifdef JITTER_HAVE_PATCH_IN
16377 
16378   /* Define argument-access macros for check-in-arity--alt/n8/fR . */
16379 #ifdef JITTER_HAVE_PATCH_IN
16380   /* Define argument-access macros assuming that fast branches are enabled. */
16381     /* The 0th argument is a nonresidual literal. */
16382 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
16383 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16384 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16385 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16386 
16387     /* The 1th argument is a "residual" fast label.  Define its
16388        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
16389        so that at replication time we know what instruction address to patch in. */
16390 #   define JITTER_ARGF1 0
16391     /* JITTER_ARG1 is intentionally not defined for a fast label. */
16392 
16393 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16394 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16395 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16396 
16397 #else
16398   /* Define argument-access macros assuming that fast branches are disabled. */
16399     /* The 0th argument is a nonresidual literal. */
16400 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
16401 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16402 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16403 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16404 #   define JITTER_ARGF0 JITTER_ARGP0
16405 
16406 #if defined(JITTER_DISPATCH_NO_THREADING)
16407 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
16408     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16409 #elif defined (JITTER_REPLICATE)
16410 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
16411 #else
16412 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
16413 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16414 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16415 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16416 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16417 #   define JITTER_ARGF1 JITTER_ARGP1
16418 
16419 # endif // #ifdef JITTER_HAVE_PATCH_IN
16420 
16421 #if defined (JITTER_PROFILE_SAMPLE)
16422   JITTER_PROFILE_SAMPLE_UPDATE
16423      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16424       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16425   /* Force the compiler not move sample-profiling instrumentation
16426      beyond this point; this way the actual user code is timed.
16427      This is still not perfect, as residuals are materialised before
16428      we arrive here, but should be adequate at least for slow VM
16429      instructions. */
16430   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16431 #endif
16432 #if defined (JITTER_PROFILE_COUNT)
16433   /* Notice that, differently from the code above, this
16434      instrumentation code *can* be reordered freely: as long as a
16435      VM instruction is counted, the count increment can be placed
16436      anyehere.  Let GCC move this code and possibly achieve better
16437      throughput by exploiting instruction-level parallelism and
16438      therefore approximate more closely a non-profiled build. */
16439   JITTER_PROFILE_COUNT_UPDATE
16440      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16441       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16442 #endif
16443 
16444 /* User-specified code, instruction-beginning-c part: beginning. */
16445 
16446 
16447 /* User-specified code, instruction-beginning-c part: end */
16448 
16449 
16450     /* User code for check-in-arity--alt/n8/fR . */
16451 
16452     // FIXME: this loops forever with no-threading (not with the other dispatching models
16453     // including minimal threading) when the callee is compiled.  A Jitter bug.
16454     /* Here we can assume that the top object is a closure, without checking: we either
16455        already performed a type check, or the compiler decided it wasn't necessary. */
16456     jitterlisp_object top = JITTER_TOP_MAINSTACK();
16457     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
16458 
16459     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
16460        from the closure compiledness.  [Done] */
16461     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
16462       {
16463         if (c->in_arity != JITTER_ARGN0)
16464           JITTER_BRANCH_FAST(JITTER_ARGF1);
16465       }
16466     else
16467       {
16468         /* The closure is interpreted.  Compute its in-arity.  We can assume that
16469            the formal list is well-formal, which is to say actually a proper list
16470            of distinct symbols. */
16471         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
16472         jitterlisp_object rest = ic->formals;
16473         jitter_uint in_arity = 0;
16474         while (! JITTERLISP_IS_EMPTY_LIST(rest))
16475           {
16476             in_arity ++;
16477             rest = JITTERLISP_EXP_C_A_CDR(rest);
16478           }
16479         if (in_arity != JITTER_ARGN0)
16480           JITTER_BRANCH_FAST(JITTER_ARGF1);
16481       }
16482 
16483     /* End of the user code for check-in-arity--alt/n8/fR . */
16484 
16485 /* User-specified code, instruction-end-c part: beginning. */
16486 
16487 
16488 /* User-specified code, instruction-end-c part: end */
16489 
16490     /* Undefine the check-in-arity--alt/n8/fR argument macros so they can't be used
16491        by mistake in the instruction body coming next. */
16492 #   undef JITTER_SLOW_REGISTER_OFFSET0
16493 #   undef JITTER_ARG0
16494 #   undef JITTER_ARGN0
16495 #   undef JITTER_ARGU0
16496 #   undef JITTER_ARGP0
16497 #   undef JITTER_ARGF0
16498 #   undef JITTER_SLOW_REGISTER_OFFSET1
16499 #   undef JITTER_ARG1
16500 #   undef JITTER_ARGN1
16501 #   undef JITTER_ARGU1
16502 #   undef JITTER_ARGP1
16503 #   undef JITTER_ARGF1
16504 
16505 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16506 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16507 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16508 
16509   }
16510  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n8/fR, check_min_marity_m_malt__n8__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16511 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16512 
16513   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n9/fR, check_min_marity_m_malt__n9__fR, hot)
16514   {
16515     /* This specialized instruction is not a replacement. */
16516 #   undef JITTER_BRANCH_FAST
16517 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16518 #   undef JITTER_BRANCH_FAST_IF_ZERO
16519 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16520 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16521 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16522 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16523 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16524 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16525 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16526 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16527 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16528 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16529 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16530 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16531 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16532 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16533 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16534 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16535 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16536 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16537 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16538 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16539 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16540 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16541 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16542 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16543 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16544 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16545 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16546 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16547 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16548 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16549 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16550 #   undef JITTER_BRANCH_FAST_IF_AND
16551 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16552 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16553 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16554 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16555 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16556 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16557 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16558 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16559 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16560 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16561 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16562 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16563 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16564 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16565 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16566 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16567 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16568 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16569 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16570 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16571 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16572 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16573 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16574 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16575 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16576 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16577 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16578 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16579 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16580 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       75
16581 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n9/fR
16582 
16583 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n9__fR
16584 
16585   /* The residual arity varies depending on whether we have fast labels. */
16586 #ifdef JITTER_HAVE_PATCH_IN
16587   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
16588 #else
16589   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16590 #endif // #ifdef JITTER_HAVE_PATCH_IN
16591 
16592   /* Define argument-access macros for check-in-arity--alt/n9/fR . */
16593 #ifdef JITTER_HAVE_PATCH_IN
16594   /* Define argument-access macros assuming that fast branches are enabled. */
16595     /* The 0th argument is a nonresidual literal. */
16596 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
16597 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16598 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16599 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16600 
16601     /* The 1th argument is a "residual" fast label.  Define its
16602        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
16603        so that at replication time we know what instruction address to patch in. */
16604 #   define JITTER_ARGF1 0
16605     /* JITTER_ARG1 is intentionally not defined for a fast label. */
16606 
16607 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16608 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16609 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16610 
16611 #else
16612   /* Define argument-access macros assuming that fast branches are disabled. */
16613     /* The 0th argument is a nonresidual literal. */
16614 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
16615 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16616 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16617 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16618 #   define JITTER_ARGF0 JITTER_ARGP0
16619 
16620 #if defined(JITTER_DISPATCH_NO_THREADING)
16621 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
16622     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16623 #elif defined (JITTER_REPLICATE)
16624 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
16625 #else
16626 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
16627 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16628 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16629 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16630 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16631 #   define JITTER_ARGF1 JITTER_ARGP1
16632 
16633 # endif // #ifdef JITTER_HAVE_PATCH_IN
16634 
16635 #if defined (JITTER_PROFILE_SAMPLE)
16636   JITTER_PROFILE_SAMPLE_UPDATE
16637      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16638       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16639   /* Force the compiler not move sample-profiling instrumentation
16640      beyond this point; this way the actual user code is timed.
16641      This is still not perfect, as residuals are materialised before
16642      we arrive here, but should be adequate at least for slow VM
16643      instructions. */
16644   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16645 #endif
16646 #if defined (JITTER_PROFILE_COUNT)
16647   /* Notice that, differently from the code above, this
16648      instrumentation code *can* be reordered freely: as long as a
16649      VM instruction is counted, the count increment can be placed
16650      anyehere.  Let GCC move this code and possibly achieve better
16651      throughput by exploiting instruction-level parallelism and
16652      therefore approximate more closely a non-profiled build. */
16653   JITTER_PROFILE_COUNT_UPDATE
16654      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16655       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16656 #endif
16657 
16658 /* User-specified code, instruction-beginning-c part: beginning. */
16659 
16660 
16661 /* User-specified code, instruction-beginning-c part: end */
16662 
16663 
16664     /* User code for check-in-arity--alt/n9/fR . */
16665 
16666     // FIXME: this loops forever with no-threading (not with the other dispatching models
16667     // including minimal threading) when the callee is compiled.  A Jitter bug.
16668     /* Here we can assume that the top object is a closure, without checking: we either
16669        already performed a type check, or the compiler decided it wasn't necessary. */
16670     jitterlisp_object top = JITTER_TOP_MAINSTACK();
16671     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
16672 
16673     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
16674        from the closure compiledness.  [Done] */
16675     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
16676       {
16677         if (c->in_arity != JITTER_ARGN0)
16678           JITTER_BRANCH_FAST(JITTER_ARGF1);
16679       }
16680     else
16681       {
16682         /* The closure is interpreted.  Compute its in-arity.  We can assume that
16683            the formal list is well-formal, which is to say actually a proper list
16684            of distinct symbols. */
16685         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
16686         jitterlisp_object rest = ic->formals;
16687         jitter_uint in_arity = 0;
16688         while (! JITTERLISP_IS_EMPTY_LIST(rest))
16689           {
16690             in_arity ++;
16691             rest = JITTERLISP_EXP_C_A_CDR(rest);
16692           }
16693         if (in_arity != JITTER_ARGN0)
16694           JITTER_BRANCH_FAST(JITTER_ARGF1);
16695       }
16696 
16697     /* End of the user code for check-in-arity--alt/n9/fR . */
16698 
16699 /* User-specified code, instruction-end-c part: beginning. */
16700 
16701 
16702 /* User-specified code, instruction-end-c part: end */
16703 
16704     /* Undefine the check-in-arity--alt/n9/fR argument macros so they can't be used
16705        by mistake in the instruction body coming next. */
16706 #   undef JITTER_SLOW_REGISTER_OFFSET0
16707 #   undef JITTER_ARG0
16708 #   undef JITTER_ARGN0
16709 #   undef JITTER_ARGU0
16710 #   undef JITTER_ARGP0
16711 #   undef JITTER_ARGF0
16712 #   undef JITTER_SLOW_REGISTER_OFFSET1
16713 #   undef JITTER_ARG1
16714 #   undef JITTER_ARGN1
16715 #   undef JITTER_ARGU1
16716 #   undef JITTER_ARGP1
16717 #   undef JITTER_ARGF1
16718 
16719 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16720 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16721 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16722 
16723   }
16724  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n9/fR, check_min_marity_m_malt__n9__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16725 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16726 
16727   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/n10/fR, check_min_marity_m_malt__n10__fR, hot)
16728   {
16729     /* This specialized instruction is not a replacement. */
16730 #   undef JITTER_BRANCH_FAST
16731 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16732 #   undef JITTER_BRANCH_FAST_IF_ZERO
16733 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16734 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16735 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16736 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16737 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16738 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16739 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16740 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16741 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16742 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16743 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16744 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16745 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16746 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16747 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16748 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16749 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16750 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16751 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16752 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16753 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16754 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16755 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16756 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16757 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16758 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16759 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16760 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16761 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16762 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16763 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16764 #   undef JITTER_BRANCH_FAST_IF_AND
16765 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16766 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16767 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16768 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16769 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16770 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16771 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16772 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16773 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16774 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16775 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16776 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16777 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16778 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16779 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16780 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16781 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16782 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16783 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16784 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16785 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16786 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16787 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
16788 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16789 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
16790 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16791 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
16792 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16793 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
16794 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       76
16795 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/n10/fR
16796 
16797 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__n10__fR
16798 
16799   /* The residual arity varies depending on whether we have fast labels. */
16800 #ifdef JITTER_HAVE_PATCH_IN
16801   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
16802 #else
16803   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
16804 #endif // #ifdef JITTER_HAVE_PATCH_IN
16805 
16806   /* Define argument-access macros for check-in-arity--alt/n10/fR . */
16807 #ifdef JITTER_HAVE_PATCH_IN
16808   /* Define argument-access macros assuming that fast branches are enabled. */
16809     /* The 0th argument is a nonresidual literal. */
16810 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
16811 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16812 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16813 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16814 
16815     /* The 1th argument is a "residual" fast label.  Define its
16816        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
16817        so that at replication time we know what instruction address to patch in. */
16818 #   define JITTER_ARGF1 0
16819     /* JITTER_ARG1 is intentionally not defined for a fast label. */
16820 
16821 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16822 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16823 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16824 
16825 #else
16826   /* Define argument-access macros assuming that fast branches are disabled. */
16827     /* The 0th argument is a nonresidual literal. */
16828 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
16829 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
16830 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
16831 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
16832 #   define JITTER_ARGF0 JITTER_ARGP0
16833 
16834 #if defined(JITTER_DISPATCH_NO_THREADING)
16835 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
16836     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
16837 #elif defined (JITTER_REPLICATE)
16838 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
16839 #else
16840 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
16841 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
16842 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
16843 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
16844 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
16845 #   define JITTER_ARGF1 JITTER_ARGP1
16846 
16847 # endif // #ifdef JITTER_HAVE_PATCH_IN
16848 
16849 #if defined (JITTER_PROFILE_SAMPLE)
16850   JITTER_PROFILE_SAMPLE_UPDATE
16851      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16852       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16853   /* Force the compiler not move sample-profiling instrumentation
16854      beyond this point; this way the actual user code is timed.
16855      This is still not perfect, as residuals are materialised before
16856      we arrive here, but should be adequate at least for slow VM
16857      instructions. */
16858   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
16859 #endif
16860 #if defined (JITTER_PROFILE_COUNT)
16861   /* Notice that, differently from the code above, this
16862      instrumentation code *can* be reordered freely: as long as a
16863      VM instruction is counted, the count increment can be placed
16864      anyehere.  Let GCC move this code and possibly achieve better
16865      throughput by exploiting instruction-level parallelism and
16866      therefore approximate more closely a non-profiled build. */
16867   JITTER_PROFILE_COUNT_UPDATE
16868      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
16869       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
16870 #endif
16871 
16872 /* User-specified code, instruction-beginning-c part: beginning. */
16873 
16874 
16875 /* User-specified code, instruction-beginning-c part: end */
16876 
16877 
16878     /* User code for check-in-arity--alt/n10/fR . */
16879 
16880     // FIXME: this loops forever with no-threading (not with the other dispatching models
16881     // including minimal threading) when the callee is compiled.  A Jitter bug.
16882     /* Here we can assume that the top object is a closure, without checking: we either
16883        already performed a type check, or the compiler decided it wasn't necessary. */
16884     jitterlisp_object top = JITTER_TOP_MAINSTACK();
16885     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
16886 
16887     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
16888        from the closure compiledness.  [Done] */
16889     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
16890       {
16891         if (c->in_arity != JITTER_ARGN0)
16892           JITTER_BRANCH_FAST(JITTER_ARGF1);
16893       }
16894     else
16895       {
16896         /* The closure is interpreted.  Compute its in-arity.  We can assume that
16897            the formal list is well-formal, which is to say actually a proper list
16898            of distinct symbols. */
16899         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
16900         jitterlisp_object rest = ic->formals;
16901         jitter_uint in_arity = 0;
16902         while (! JITTERLISP_IS_EMPTY_LIST(rest))
16903           {
16904             in_arity ++;
16905             rest = JITTERLISP_EXP_C_A_CDR(rest);
16906           }
16907         if (in_arity != JITTER_ARGN0)
16908           JITTER_BRANCH_FAST(JITTER_ARGF1);
16909       }
16910 
16911     /* End of the user code for check-in-arity--alt/n10/fR . */
16912 
16913 /* User-specified code, instruction-end-c part: beginning. */
16914 
16915 
16916 /* User-specified code, instruction-end-c part: end */
16917 
16918     /* Undefine the check-in-arity--alt/n10/fR argument macros so they can't be used
16919        by mistake in the instruction body coming next. */
16920 #   undef JITTER_SLOW_REGISTER_OFFSET0
16921 #   undef JITTER_ARG0
16922 #   undef JITTER_ARGN0
16923 #   undef JITTER_ARGU0
16924 #   undef JITTER_ARGP0
16925 #   undef JITTER_ARGF0
16926 #   undef JITTER_SLOW_REGISTER_OFFSET1
16927 #   undef JITTER_ARG1
16928 #   undef JITTER_ARGN1
16929 #   undef JITTER_ARGU1
16930 #   undef JITTER_ARGP1
16931 #   undef JITTER_ARGF1
16932 
16933 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
16934 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
16935 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
16936 
16937   }
16938  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/n10/fR, check_min_marity_m_malt__n10__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
16939 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
16940 
16941   JITTER_INSTRUCTION_PROLOG_(check-in-arity--alt/nR/fR, check_min_marity_m_malt__nR__fR, cold)
16942   {
16943     /* This specialized instruction is not a replacement. */
16944 #   undef JITTER_BRANCH_FAST
16945 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
16946 #   undef JITTER_BRANCH_FAST_IF_ZERO
16947 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
16948 #   undef JITTER_BRANCH_FAST_IF_NONZERO
16949 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
16950 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
16951 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
16952 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
16953 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
16954 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
16955 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
16956 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
16957 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
16958 #   undef JITTER_BRANCH_FAST_IF_EQUAL
16959 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
16960 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
16961 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
16962 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
16963 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
16964 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16965 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
16966 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16967 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
16968 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16969 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
16970 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16971 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
16972 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16973 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
16974 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16975 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
16976 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16977 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
16978 #   undef JITTER_BRANCH_FAST_IF_AND
16979 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
16980 #   undef JITTER_BRANCH_FAST_IF_NOTAND
16981 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
16982 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16983 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
16984 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16985 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
16986 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16987 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
16988 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16989 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
16990 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16991 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
16992 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16993 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
16994 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16995 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
16996 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16997 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
16998 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
16999 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17000 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17001 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17002 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17003 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17004 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17005 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17006 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17007 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17008 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       77
17009 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         check-in-arity--alt/nR/fR
17010 
17011 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME check_min_marity_m_malt__nR__fR
17012 
17013   /* The residual arity varies depending on whether we have fast labels. */
17014 #ifdef JITTER_HAVE_PATCH_IN
17015   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
17016 #else
17017   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
17018 #endif // #ifdef JITTER_HAVE_PATCH_IN
17019 
17020   /* Define argument-access macros for check-in-arity--alt/nR/fR . */
17021 #ifdef JITTER_HAVE_PATCH_IN
17022   /* Define argument-access macros assuming that fast branches are enabled. */
17023     /* The 0th argument is a residual literal. */
17024 #if defined(JITTER_DISPATCH_NO_THREADING)
17025 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
17026     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
17027 #elif defined (JITTER_REPLICATE)
17028 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
17029 #else
17030 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
17031 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
17032 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
17033 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
17034 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
17035 
17036     /* The 1th argument is a "residual" fast label.  Define its
17037        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
17038        so that at replication time we know what instruction address to patch in. */
17039 #   define JITTER_ARGF1 0
17040     /* JITTER_ARG1 is intentionally not defined for a fast label. */
17041 
17042 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
17043 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
17044 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
17045 
17046 #else
17047   /* Define argument-access macros assuming that fast branches are disabled. */
17048     /* The 0th argument is a residual literal. */
17049 #if defined(JITTER_DISPATCH_NO_THREADING)
17050 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
17051     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
17052 #elif defined (JITTER_REPLICATE)
17053 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
17054 #else
17055 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
17056 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
17057 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
17058 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
17059 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
17060 #   define JITTER_ARGF0 JITTER_ARGP0
17061 
17062 #if defined(JITTER_DISPATCH_NO_THREADING)
17063 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
17064     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
17065 #elif defined (JITTER_REPLICATE)
17066 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
17067 #else
17068 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
17069 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
17070 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
17071 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
17072 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
17073 #   define JITTER_ARGF1 JITTER_ARGP1
17074 
17075 # endif // #ifdef JITTER_HAVE_PATCH_IN
17076 
17077 #if defined (JITTER_PROFILE_SAMPLE)
17078   JITTER_PROFILE_SAMPLE_UPDATE
17079      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17080       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17081   /* Force the compiler not move sample-profiling instrumentation
17082      beyond this point; this way the actual user code is timed.
17083      This is still not perfect, as residuals are materialised before
17084      we arrive here, but should be adequate at least for slow VM
17085      instructions. */
17086   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17087 #endif
17088 #if defined (JITTER_PROFILE_COUNT)
17089   /* Notice that, differently from the code above, this
17090      instrumentation code *can* be reordered freely: as long as a
17091      VM instruction is counted, the count increment can be placed
17092      anyehere.  Let GCC move this code and possibly achieve better
17093      throughput by exploiting instruction-level parallelism and
17094      therefore approximate more closely a non-profiled build. */
17095   JITTER_PROFILE_COUNT_UPDATE
17096      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17097       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17098 #endif
17099 
17100 /* User-specified code, instruction-beginning-c part: beginning. */
17101 
17102 
17103 /* User-specified code, instruction-beginning-c part: end */
17104 
17105 
17106     /* User code for check-in-arity--alt/nR/fR . */
17107 
17108     // FIXME: this loops forever with no-threading (not with the other dispatching models
17109     // including minimal threading) when the callee is compiled.  A Jitter bug.
17110     /* Here we can assume that the top object is a closure, without checking: we either
17111        already performed a type check, or the compiler decided it wasn't necessary. */
17112     jitterlisp_object top = JITTER_TOP_MAINSTACK();
17113     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
17114 
17115     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
17116        from the closure compiledness.  [Done] */
17117     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
17118       {
17119         if (c->in_arity != JITTER_ARGN0)
17120           JITTER_BRANCH_FAST(JITTER_ARGF1);
17121       }
17122     else
17123       {
17124         /* The closure is interpreted.  Compute its in-arity.  We can assume that
17125            the formal list is well-formal, which is to say actually a proper list
17126            of distinct symbols. */
17127         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
17128         jitterlisp_object rest = ic->formals;
17129         jitter_uint in_arity = 0;
17130         while (! JITTERLISP_IS_EMPTY_LIST(rest))
17131           {
17132             in_arity ++;
17133             rest = JITTERLISP_EXP_C_A_CDR(rest);
17134           }
17135         if (in_arity != JITTER_ARGN0)
17136           JITTER_BRANCH_FAST(JITTER_ARGF1);
17137       }
17138 
17139     /* End of the user code for check-in-arity--alt/nR/fR . */
17140 
17141 /* User-specified code, instruction-end-c part: beginning. */
17142 
17143 
17144 /* User-specified code, instruction-end-c part: end */
17145 
17146     /* Undefine the check-in-arity--alt/nR/fR argument macros so they can't be used
17147        by mistake in the instruction body coming next. */
17148 #   undef JITTER_SLOW_REGISTER_OFFSET0
17149 #   undef JITTER_ARG0
17150 #   undef JITTER_ARGN0
17151 #   undef JITTER_ARGU0
17152 #   undef JITTER_ARGP0
17153 #   undef JITTER_ARGF0
17154 #   undef JITTER_SLOW_REGISTER_OFFSET1
17155 #   undef JITTER_ARG1
17156 #   undef JITTER_ARGN1
17157 #   undef JITTER_ARGU1
17158 #   undef JITTER_ARGP1
17159 #   undef JITTER_ARGF1
17160 
17161 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17162 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17163 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17164 
17165   }
17166  JITTER_INSTRUCTION_EPILOG_(check-in-arity--alt/nR/fR, check_min_marity_m_malt__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17167 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17168 
17169   JITTER_INSTRUCTION_PROLOG_(copy-from-literal/nR, copy_mfrom_mliteral__nR, cold)
17170   {
17171     /* This specialized instruction is not a replacement. */
17172 #   undef JITTER_BRANCH_FAST
17173 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17174 #   undef JITTER_BRANCH_FAST_IF_ZERO
17175 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17176 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17177 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17178 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17179 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17180 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17181 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17182 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17183 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17184 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17185 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17186 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17187 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17188 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17189 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17190 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17191 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17192 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17193 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17194 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17195 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17196 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17197 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17198 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17199 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17200 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17201 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17202 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17203 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17204 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17205 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17206 #   undef JITTER_BRANCH_FAST_IF_AND
17207 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17208 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17209 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17210 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17211 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17212 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17213 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17214 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17215 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17216 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17217 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17218 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17219 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17220 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17221 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17222 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17223 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17224 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17225 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17226 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17227 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17228 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17229 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17230 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17231 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17232 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17233 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17234 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17235 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17236 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       78
17237 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         copy-from-literal/nR
17238 
17239 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME copy_mfrom_mliteral__nR
17240 
17241   /* The residual arity for this instruction does not depend on fast labels. */
17242   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
17243 
17244     /* The 0th argument is a residual literal. */
17245 #if defined(JITTER_DISPATCH_NO_THREADING)
17246 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
17247     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
17248 #elif defined (JITTER_REPLICATE)
17249 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
17250 #else
17251 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
17252 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
17253 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
17254 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
17255 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
17256 #   define JITTER_ARGF0 JITTER_ARGP0
17257 
17258 
17259 #if defined (JITTER_PROFILE_SAMPLE)
17260   JITTER_PROFILE_SAMPLE_UPDATE
17261      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17262       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17263   /* Force the compiler not move sample-profiling instrumentation
17264      beyond this point; this way the actual user code is timed.
17265      This is still not perfect, as residuals are materialised before
17266      we arrive here, but should be adequate at least for slow VM
17267      instructions. */
17268   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17269 #endif
17270 #if defined (JITTER_PROFILE_COUNT)
17271   /* Notice that, differently from the code above, this
17272      instrumentation code *can* be reordered freely: as long as a
17273      VM instruction is counted, the count increment can be placed
17274      anyehere.  Let GCC move this code and possibly achieve better
17275      throughput by exploiting instruction-level parallelism and
17276      therefore approximate more closely a non-profiled build. */
17277   JITTER_PROFILE_COUNT_UPDATE
17278      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17279       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17280 #endif
17281 
17282 /* User-specified code, instruction-beginning-c part: beginning. */
17283 
17284 
17285 /* User-specified code, instruction-beginning-c part: end */
17286 
17287 
17288     /* User code for copy-from-literal/nR . */
17289 
17290     JITTER_TOP_MAINSTACK() = JITTER_ARGN0;
17291 
17292     /* End of the user code for copy-from-literal/nR . */
17293 
17294 /* User-specified code, instruction-end-c part: beginning. */
17295 
17296 
17297 /* User-specified code, instruction-end-c part: end */
17298 
17299     /* Undefine the copy-from-literal/nR argument macros so they can't be used
17300        by mistake in the instruction body coming next. */
17301 #   undef JITTER_SLOW_REGISTER_OFFSET0
17302 #   undef JITTER_ARG0
17303 #   undef JITTER_ARGN0
17304 #   undef JITTER_ARGU0
17305 #   undef JITTER_ARGP0
17306 #   undef JITTER_ARGF0
17307 
17308 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17309 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17310 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17311 
17312   }
17313  JITTER_INSTRUCTION_EPILOG_(copy-from-literal/nR, copy_mfrom_mliteral__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17314 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17315 
17316   JITTER_INSTRUCTION_PROLOG_(copy-from-register/%rR, copy_mfrom_mregister___rrR, cold)
17317   {
17318     /* This specialized instruction is not a replacement. */
17319 #   undef JITTER_BRANCH_FAST
17320 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17321 #   undef JITTER_BRANCH_FAST_IF_ZERO
17322 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17323 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17324 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17325 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17326 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17327 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17328 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17329 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17330 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17331 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17332 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17333 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17334 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17335 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17336 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17337 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17338 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17339 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17340 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17341 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17342 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17343 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17344 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17345 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17346 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17347 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17348 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17349 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17350 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17351 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17352 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17353 #   undef JITTER_BRANCH_FAST_IF_AND
17354 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17355 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17356 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17357 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17358 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17359 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17360 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17361 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17362 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17363 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17364 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17365 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17366 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17367 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17368 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17369 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17370 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17371 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17372 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17373 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17374 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17375 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17376 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17377 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17378 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17379 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17380 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17381 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17382 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17383 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       79
17384 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         copy-from-register/%rR
17385 
17386 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME copy_mfrom_mregister___rrR
17387 
17388   /* The residual arity for this instruction does not depend on fast labels. */
17389   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
17390 
17391     /* The 0th argument is a slow (therefore residual, passed as an offset)
17392         register. */
17393   /* Define a macro expanding to the slow register offset. */
17394 #if defined(JITTER_DISPATCH_NO_THREADING)
17395 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
17396 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
17397 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
17398 #else
17399 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
17400 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
17401   /* Define a macro expanding to an l-value for the VM register content. */
17402 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
17403 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
17404 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
17405 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
17406 #   define JITTER_ARGF0 JITTER_ARGP0
17407 
17408 
17409 #if defined (JITTER_PROFILE_SAMPLE)
17410   JITTER_PROFILE_SAMPLE_UPDATE
17411      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17412       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17413   /* Force the compiler not move sample-profiling instrumentation
17414      beyond this point; this way the actual user code is timed.
17415      This is still not perfect, as residuals are materialised before
17416      we arrive here, but should be adequate at least for slow VM
17417      instructions. */
17418   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17419 #endif
17420 #if defined (JITTER_PROFILE_COUNT)
17421   /* Notice that, differently from the code above, this
17422      instrumentation code *can* be reordered freely: as long as a
17423      VM instruction is counted, the count increment can be placed
17424      anyehere.  Let GCC move this code and possibly achieve better
17425      throughput by exploiting instruction-level parallelism and
17426      therefore approximate more closely a non-profiled build. */
17427   JITTER_PROFILE_COUNT_UPDATE
17428      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17429       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17430 #endif
17431 
17432 /* User-specified code, instruction-beginning-c part: beginning. */
17433 
17434 
17435 /* User-specified code, instruction-beginning-c part: end */
17436 
17437 
17438     /* User code for copy-from-register/%rR . */
17439 
17440     JITTER_TOP_MAINSTACK() = JITTER_ARG0;
17441 
17442     /* End of the user code for copy-from-register/%rR . */
17443 
17444 /* User-specified code, instruction-end-c part: beginning. */
17445 
17446 
17447 /* User-specified code, instruction-end-c part: end */
17448 
17449     /* Undefine the copy-from-register/%rR argument macros so they can't be used
17450        by mistake in the instruction body coming next. */
17451 #   undef JITTER_SLOW_REGISTER_OFFSET0
17452 #   undef JITTER_ARG0
17453 #   undef JITTER_ARGN0
17454 #   undef JITTER_ARGU0
17455 #   undef JITTER_ARGP0
17456 #   undef JITTER_ARGF0
17457 
17458 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17459 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17460 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17461 
17462   }
17463  JITTER_INSTRUCTION_EPILOG_(copy-from-register/%rR, copy_mfrom_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17464 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17465 
17466   JITTER_INSTRUCTION_PROLOG_(copy-to-register/%rR, copy_mto_mregister___rrR, cold)
17467   {
17468     /* This specialized instruction is not a replacement. */
17469 #   undef JITTER_BRANCH_FAST
17470 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17471 #   undef JITTER_BRANCH_FAST_IF_ZERO
17472 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17473 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17474 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17475 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17476 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17477 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17478 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17479 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17480 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17481 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17482 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17483 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17484 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17485 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17486 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17487 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17488 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17489 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17490 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17491 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17492 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17493 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17494 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17495 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17496 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17497 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17498 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17499 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17500 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17501 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17502 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17503 #   undef JITTER_BRANCH_FAST_IF_AND
17504 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17505 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17506 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17507 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17508 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17509 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17510 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17511 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17512 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17513 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17514 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17515 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17516 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17517 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17518 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17519 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17520 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17521 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17522 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17523 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17524 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17525 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17526 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17527 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17528 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17529 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17530 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17531 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17532 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17533 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       80
17534 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         copy-to-register/%rR
17535 
17536 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME copy_mto_mregister___rrR
17537 
17538   /* The residual arity for this instruction does not depend on fast labels. */
17539   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
17540 
17541     /* The 0th argument is a slow (therefore residual, passed as an offset)
17542         register. */
17543   /* Define a macro expanding to the slow register offset. */
17544 #if defined(JITTER_DISPATCH_NO_THREADING)
17545 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
17546 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
17547 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
17548 #else
17549 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
17550 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
17551   /* Define a macro expanding to an l-value for the VM register content. */
17552 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
17553 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
17554 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
17555 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
17556 #   define JITTER_ARGF0 JITTER_ARGP0
17557 
17558 
17559 #if defined (JITTER_PROFILE_SAMPLE)
17560   JITTER_PROFILE_SAMPLE_UPDATE
17561      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17562       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17563   /* Force the compiler not move sample-profiling instrumentation
17564      beyond this point; this way the actual user code is timed.
17565      This is still not perfect, as residuals are materialised before
17566      we arrive here, but should be adequate at least for slow VM
17567      instructions. */
17568   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17569 #endif
17570 #if defined (JITTER_PROFILE_COUNT)
17571   /* Notice that, differently from the code above, this
17572      instrumentation code *can* be reordered freely: as long as a
17573      VM instruction is counted, the count increment can be placed
17574      anyehere.  Let GCC move this code and possibly achieve better
17575      throughput by exploiting instruction-level parallelism and
17576      therefore approximate more closely a non-profiled build. */
17577   JITTER_PROFILE_COUNT_UPDATE
17578      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17579       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17580 #endif
17581 
17582 /* User-specified code, instruction-beginning-c part: beginning. */
17583 
17584 
17585 /* User-specified code, instruction-beginning-c part: end */
17586 
17587 
17588     /* User code for copy-to-register/%rR . */
17589 
17590     JITTER_ARG0 = JITTER_TOP_MAINSTACK();
17591 
17592     /* End of the user code for copy-to-register/%rR . */
17593 
17594 /* User-specified code, instruction-end-c part: beginning. */
17595 
17596 
17597 /* User-specified code, instruction-end-c part: end */
17598 
17599     /* Undefine the copy-to-register/%rR argument macros so they can't be used
17600        by mistake in the instruction body coming next. */
17601 #   undef JITTER_SLOW_REGISTER_OFFSET0
17602 #   undef JITTER_ARG0
17603 #   undef JITTER_ARGN0
17604 #   undef JITTER_ARGU0
17605 #   undef JITTER_ARGP0
17606 #   undef JITTER_ARGF0
17607 
17608 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17609 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17610 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17611 
17612   }
17613  JITTER_INSTRUCTION_EPILOG_(copy-to-register/%rR, copy_mto_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17614 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17615 
17616   JITTER_INSTRUCTION_PROLOG_(drop, drop, hot)
17617   {
17618     /* This specialized instruction is not a replacement. */
17619 #   undef JITTER_BRANCH_FAST
17620 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17621 #   undef JITTER_BRANCH_FAST_IF_ZERO
17622 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17623 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17624 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17625 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17626 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17627 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17628 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17629 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17630 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17631 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17632 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17633 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17634 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17635 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17636 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17637 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17638 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17639 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17640 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17641 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17642 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17643 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17644 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17645 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17646 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17647 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17648 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17649 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17650 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17651 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17652 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17653 #   undef JITTER_BRANCH_FAST_IF_AND
17654 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17655 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17656 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17657 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17658 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17659 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17660 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17661 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17662 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17663 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17664 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17665 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17666 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17667 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17668 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17669 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17670 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17671 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17672 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17673 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17674 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17675 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17676 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17677 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17678 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17679 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17680 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17681 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17682 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17683 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       81
17684 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop
17685 
17686 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop
17687 
17688   /* The residual arity for this instruction does not depend on fast labels. */
17689   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17690 
17691 
17692 #if defined (JITTER_PROFILE_SAMPLE)
17693   JITTER_PROFILE_SAMPLE_UPDATE
17694      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17695       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17696   /* Force the compiler not move sample-profiling instrumentation
17697      beyond this point; this way the actual user code is timed.
17698      This is still not perfect, as residuals are materialised before
17699      we arrive here, but should be adequate at least for slow VM
17700      instructions. */
17701   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17702 #endif
17703 #if defined (JITTER_PROFILE_COUNT)
17704   /* Notice that, differently from the code above, this
17705      instrumentation code *can* be reordered freely: as long as a
17706      VM instruction is counted, the count increment can be placed
17707      anyehere.  Let GCC move this code and possibly achieve better
17708      throughput by exploiting instruction-level parallelism and
17709      therefore approximate more closely a non-profiled build. */
17710   JITTER_PROFILE_COUNT_UPDATE
17711      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17712       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17713 #endif
17714 
17715 /* User-specified code, instruction-beginning-c part: beginning. */
17716 
17717 
17718 /* User-specified code, instruction-beginning-c part: end */
17719 
17720 
17721     /* User code for drop . */
17722 
17723     JITTER_DROP_MAINSTACK();
17724 
17725     /* End of the user code for drop . */
17726 
17727 /* User-specified code, instruction-end-c part: beginning. */
17728 
17729 
17730 /* User-specified code, instruction-end-c part: end */
17731 
17732     /* Undefine the drop argument macros so they can't be used
17733        by mistake in the instruction body coming next. */
17734 
17735 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17736 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17737 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17738 
17739   }
17740  JITTER_INSTRUCTION_EPILOG_(drop, drop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17741 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17742 
17743   JITTER_INSTRUCTION_PROLOG_(drop-nip, drop_mnip, hot)
17744   {
17745     /* This specialized instruction is not a replacement. */
17746 #   undef JITTER_BRANCH_FAST
17747 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17748 #   undef JITTER_BRANCH_FAST_IF_ZERO
17749 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17750 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17751 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17752 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17753 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17754 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17755 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17756 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17757 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17758 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17759 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17760 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17761 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17762 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17763 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17764 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17765 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17766 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17767 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17768 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17769 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17770 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17771 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17772 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17773 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17774 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17775 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17776 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17777 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17778 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17779 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17780 #   undef JITTER_BRANCH_FAST_IF_AND
17781 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17782 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17783 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17784 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17785 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17786 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17787 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17788 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17789 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17790 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17791 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17792 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17793 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17794 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17795 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17796 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17797 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17798 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17799 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17800 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17801 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17802 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17803 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17804 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17805 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17806 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17807 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17808 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17809 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17810 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       82
17811 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         drop-nip
17812 
17813 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME drop_mnip
17814 
17815   /* The residual arity for this instruction does not depend on fast labels. */
17816   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17817 
17818 
17819 #if defined (JITTER_PROFILE_SAMPLE)
17820   JITTER_PROFILE_SAMPLE_UPDATE
17821      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17822       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17823   /* Force the compiler not move sample-profiling instrumentation
17824      beyond this point; this way the actual user code is timed.
17825      This is still not perfect, as residuals are materialised before
17826      we arrive here, but should be adequate at least for slow VM
17827      instructions. */
17828   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17829 #endif
17830 #if defined (JITTER_PROFILE_COUNT)
17831   /* Notice that, differently from the code above, this
17832      instrumentation code *can* be reordered freely: as long as a
17833      VM instruction is counted, the count increment can be placed
17834      anyehere.  Let GCC move this code and possibly achieve better
17835      throughput by exploiting instruction-level parallelism and
17836      therefore approximate more closely a non-profiled build. */
17837   JITTER_PROFILE_COUNT_UPDATE
17838      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17839       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17840 #endif
17841 
17842 /* User-specified code, instruction-beginning-c part: beginning. */
17843 
17844 
17845 /* User-specified code, instruction-beginning-c part: end */
17846 
17847 
17848     /* User code for drop-nip . */
17849 
17850     JITTER_DROP_MAINSTACK();
17851     JITTER_NIP_MAINSTACK();
17852 
17853     /* End of the user code for drop-nip . */
17854 
17855 /* User-specified code, instruction-end-c part: beginning. */
17856 
17857 
17858 /* User-specified code, instruction-end-c part: end */
17859 
17860     /* Undefine the drop-nip argument macros so they can't be used
17861        by mistake in the instruction body coming next. */
17862 
17863 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17864 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17865 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17866 
17867   }
17868  JITTER_INSTRUCTION_EPILOG_(drop-nip, drop_mnip, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17869 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17870 
17871   JITTER_INSTRUCTION_PROLOG_(dup, dup, hot)
17872   {
17873     /* This specialized instruction is not a replacement. */
17874 #   undef JITTER_BRANCH_FAST
17875 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
17876 #   undef JITTER_BRANCH_FAST_IF_ZERO
17877 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
17878 #   undef JITTER_BRANCH_FAST_IF_NONZERO
17879 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
17880 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
17881 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
17882 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
17883 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
17884 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
17885 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
17886 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
17887 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
17888 #   undef JITTER_BRANCH_FAST_IF_EQUAL
17889 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
17890 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
17891 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
17892 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
17893 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
17894 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17895 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
17896 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17897 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
17898 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17899 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
17900 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17901 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
17902 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17903 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
17904 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17905 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
17906 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17907 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
17908 #   undef JITTER_BRANCH_FAST_IF_AND
17909 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
17910 #   undef JITTER_BRANCH_FAST_IF_NOTAND
17911 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
17912 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17913 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
17914 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17915 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
17916 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17917 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
17918 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17919 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
17920 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17921 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
17922 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17923 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
17924 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17925 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
17926 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17927 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
17928 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17929 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
17930 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17931 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
17932 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17933 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
17934 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17935 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
17936 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17937 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
17938 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       83
17939 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         dup
17940 
17941 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME dup
17942 
17943   /* The residual arity for this instruction does not depend on fast labels. */
17944   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
17945 
17946 
17947 #if defined (JITTER_PROFILE_SAMPLE)
17948   JITTER_PROFILE_SAMPLE_UPDATE
17949      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17950       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17951   /* Force the compiler not move sample-profiling instrumentation
17952      beyond this point; this way the actual user code is timed.
17953      This is still not perfect, as residuals are materialised before
17954      we arrive here, but should be adequate at least for slow VM
17955      instructions. */
17956   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
17957 #endif
17958 #if defined (JITTER_PROFILE_COUNT)
17959   /* Notice that, differently from the code above, this
17960      instrumentation code *can* be reordered freely: as long as a
17961      VM instruction is counted, the count increment can be placed
17962      anyehere.  Let GCC move this code and possibly achieve better
17963      throughput by exploiting instruction-level parallelism and
17964      therefore approximate more closely a non-profiled build. */
17965   JITTER_PROFILE_COUNT_UPDATE
17966      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
17967       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
17968 #endif
17969 
17970 /* User-specified code, instruction-beginning-c part: beginning. */
17971 
17972 
17973 /* User-specified code, instruction-beginning-c part: end */
17974 
17975 
17976     /* User code for dup . */
17977 
17978     JITTER_DUP_MAINSTACK();
17979 
17980     /* End of the user code for dup . */
17981 
17982 /* User-specified code, instruction-end-c part: beginning. */
17983 
17984 
17985 /* User-specified code, instruction-end-c part: end */
17986 
17987     /* Undefine the dup argument macros so they can't be used
17988        by mistake in the instruction body coming next. */
17989 
17990 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
17991 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
17992 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
17993 
17994   }
17995  JITTER_INSTRUCTION_EPILOG_(dup, dup, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
17996 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
17997 
17998   JITTER_INSTRUCTION_PROLOG_(exitvm, exitvm, cold)
17999   {
18000     /* This specialized instruction is not a replacement. */
18001 #   undef JITTER_BRANCH_FAST
18002 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18003 #   undef JITTER_BRANCH_FAST_IF_ZERO
18004 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18005 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18006 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18007 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18008 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18009 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18010 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18011 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18012 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18013 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18014 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18015 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18016 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18017 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18018 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18019 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18020 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18021 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18022 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18023 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18024 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18025 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18026 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18027 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18028 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18029 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18030 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18031 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18032 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18033 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18034 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18035 #   undef JITTER_BRANCH_FAST_IF_AND
18036 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18037 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18038 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18039 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18040 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18041 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18042 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18043 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18044 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18045 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18046 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18047 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18048 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18049 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18050 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18051 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18052 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18053 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18054 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18055 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18056 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18057 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18058 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18059 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18060 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18061 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18062 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18063 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18064 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18065 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       84
18066 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         exitvm
18067 
18068 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME exitvm
18069 
18070   /* The residual arity for this instruction does not depend on fast labels. */
18071   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
18072 
18073 
18074 #if defined (JITTER_PROFILE_SAMPLE)
18075   JITTER_PROFILE_SAMPLE_UPDATE
18076      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18077       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18078   /* Force the compiler not move sample-profiling instrumentation
18079      beyond this point; this way the actual user code is timed.
18080      This is still not perfect, as residuals are materialised before
18081      we arrive here, but should be adequate at least for slow VM
18082      instructions. */
18083   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18084 #endif
18085 #if defined (JITTER_PROFILE_COUNT)
18086   /* Notice that, differently from the code above, this
18087      instrumentation code *can* be reordered freely: as long as a
18088      VM instruction is counted, the count increment can be placed
18089      anyehere.  Let GCC move this code and possibly achieve better
18090      throughput by exploiting instruction-level parallelism and
18091      therefore approximate more closely a non-profiled build. */
18092   JITTER_PROFILE_COUNT_UPDATE
18093      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18094       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18095 #endif
18096 
18097 /* User-specified code, instruction-beginning-c part: beginning. */
18098 
18099 
18100 /* User-specified code, instruction-beginning-c part: end */
18101 
18102 
18103     /* User code for exitvm . */
18104 JITTER_EXIT();
18105     /* End of the user code for exitvm . */
18106 
18107 /* User-specified code, instruction-end-c part: beginning. */
18108 
18109 
18110 /* User-specified code, instruction-end-c part: end */
18111 
18112     /* Undefine the exitvm argument macros so they can't be used
18113        by mistake in the instruction body coming next. */
18114 
18115 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18116 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18117 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18118 
18119   }
18120  JITTER_INSTRUCTION_EPILOG_(exitvm, exitvm, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18121 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18122 
18123   JITTER_INSTRUCTION_PROLOG_(fail/retR, fail__retR, cold)
18124   {
18125     /* This specialized instruction is not a replacement. */
18126 #   undef JITTER_BRANCH_FAST
18127 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18128 #   undef JITTER_BRANCH_FAST_IF_ZERO
18129 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18130 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18131 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18132 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18133 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18134 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18135 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18136 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18137 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18138 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18139 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18140 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18141 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18142 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18143 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18144 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18145 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18146 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18147 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18148 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18149 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18150 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18151 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18152 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18153 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18154 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18155 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18156 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18157 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18158 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18159 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18160 #   undef JITTER_BRANCH_FAST_IF_AND
18161 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18162 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18163 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18164 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18165 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18166 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18167 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18168 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18169 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18170 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18171 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18172 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18173 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18174 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18175 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18176 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18177 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18178 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18179 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18180 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18181 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18182 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18183 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18184 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18185 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18186 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18187 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18188 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18189 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18190     /* This specialized instruction is non-relocatable.
18191        Its 0-th argument, a literal, is the return address where to jump
18192        at the end, back to relocated code. */
18193 
18194 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       85
18195 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         fail/retR
18196 
18197 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME fail__retR
18198 
18199   /* The residual arity for this instruction does not depend on fast labels. */
18200   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18201 
18202     /* The 0th argument is a residual literal. */
18203 #if defined(JITTER_DISPATCH_NO_THREADING)
18204 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18205     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18206 #elif defined (JITTER_REPLICATE)
18207 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18208 #else
18209 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18210 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18211 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18212 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18213 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18214 #   define JITTER_ARGF0 JITTER_ARGP0
18215 
18216 
18217 #ifdef JITTER_REPLICATE
18218     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
18219        it on the stack rather than in read-only memory.  I had to do this to prevent
18220        a GCC 8 snapshot on SH from being too clever. */
18221     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
18222     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
18223        in memory, as a 16-bit constant; and since it reads it with a PC-relative
18224        load the relocated part crashes.
18225                  mov.w     .L1667,r0
18226                  mov.l     @(r0,r15),r1
18227                  jmp       @r1
18228        r15 is the stack pointer.  The constant at .L1667 is
18229           .L1667:
18230                  .short    232
18231        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
18232        can't work as an immediate.  Shall I keep these code pointers as a single array?
18233        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
18234        but the problem will be the same. */
18235     /* Jump to non-relocatable code. */
18236     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
18237 
18238     /* Here the residual arity is given as zero: it's too late to
18239        skip residuals, since we've already jumped and this code is
18240        unreachable.  The instruction pointer, if any, is advanced
18241        in the non-relocatable code. */
18242     JITTER_INSTRUCTION_EPILOG_(fail/retR, fail__retR, 0)
18243 
18244     /* Relocated code will jump to this label in non-relocated code. */
18245   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
18246     JITTER_COMMENT_IN_ASM_("fail/retR non-relocatable code");
18247 #endif // #ifdef JITTER_REPLICATE
18248 #if defined (JITTER_PROFILE_SAMPLE)
18249   JITTER_PROFILE_SAMPLE_UPDATE
18250      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18251       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18252   /* Force the compiler not move sample-profiling instrumentation
18253      beyond this point; this way the actual user code is timed.
18254      This is still not perfect, as residuals are materialised before
18255      we arrive here, but should be adequate at least for slow VM
18256      instructions. */
18257   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18258 #endif
18259 #if defined (JITTER_PROFILE_COUNT)
18260   /* Notice that, differently from the code above, this
18261      instrumentation code *can* be reordered freely: as long as a
18262      VM instruction is counted, the count increment can be placed
18263      anyehere.  Let GCC move this code and possibly achieve better
18264      throughput by exploiting instruction-level parallelism and
18265      therefore approximate more closely a non-profiled build. */
18266   JITTER_PROFILE_COUNT_UPDATE
18267      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18268       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18269 #endif
18270 
18271 /* User-specified code, instruction-beginning-c part: beginning. */
18272 
18273 
18274 /* User-specified code, instruction-beginning-c part: end */
18275 
18276 
18277     /* User code for fail/retR . */
18278 
18279     jitterlisp_fail_from_vm ();
18280 
18281     /* End of the user code for fail/retR . */
18282 
18283 /* User-specified code, instruction-end-c part: beginning. */
18284 
18285 
18286 /* User-specified code, instruction-end-c part: end */
18287 
18288 #ifdef JITTER_REPLICATE
18289     /* Advance the instruction pointer, if any, to skip residuals;
18290        then jump back to replicated code. */
18291     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
18292     JITTER_SKIP_RESIDUALS_;
18293     goto * _jitter_back_to_replicated_code_pointer;
18294 #endif // #ifdef JITTER_REPLICATE
18295 
18296     /* Undefine the fail/retR argument macros so they can't be used
18297        by mistake in the instruction body coming next. */
18298 #   undef JITTER_SLOW_REGISTER_OFFSET0
18299 #   undef JITTER_ARG0
18300 #   undef JITTER_ARGN0
18301 #   undef JITTER_ARGU0
18302 #   undef JITTER_ARGP0
18303 #   undef JITTER_ARGF0
18304 
18305 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18306 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18307 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18308 
18309   }
18310 #ifndef JITTER_REPLICATE
18311  JITTER_INSTRUCTION_EPILOG_(fail/retR, fail__retR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18312 #endif // #ifndef JITTER_REPLICATE
18313 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18314 
18315   JITTER_INSTRUCTION_PROLOG_(gc-if-needed/fR, gc_mif_mneeded__fR, hot)
18316   {
18317     /* This specialized instruction is not a replacement. */
18318 #   undef JITTER_BRANCH_FAST
18319 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18320 #   undef JITTER_BRANCH_FAST_IF_ZERO
18321 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18322 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18323 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18324 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18325 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18326 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18327 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18328 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18329 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18330 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18331 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18332 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18333 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18334 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18335 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18336 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18337 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18338 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18339 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18340 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18341 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18342 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18343 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18344 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18345 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18346 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18347 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18348 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18349 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18350 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18351 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18352 #   undef JITTER_BRANCH_FAST_IF_AND
18353 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18354 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18355 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18356 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18357 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18358 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18359 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18360 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18361 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18362 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18363 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18364 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18365 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18366 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18367 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18368 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18369 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18370 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18371 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18372 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18373 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18374 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18375 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18376 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18377 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18378 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18379 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18380 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18381 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18382 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       86
18383 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         gc-if-needed/fR
18384 
18385 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME gc_mif_mneeded__fR
18386 
18387   /* The residual arity varies depending on whether we have fast labels. */
18388 #ifdef JITTER_HAVE_PATCH_IN
18389   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
18390 #else
18391   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
18392 #endif // #ifdef JITTER_HAVE_PATCH_IN
18393 
18394   /* Define argument-access macros for gc-if-needed/fR . */
18395 #ifdef JITTER_HAVE_PATCH_IN
18396   /* Define argument-access macros assuming that fast branches are enabled. */
18397     /* The 0th argument is a "residual" fast label.  Define its
18398        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
18399        so that at replication time we know what instruction address to patch in. */
18400 #   define JITTER_ARGF0 0
18401     /* JITTER_ARG0 is intentionally not defined for a fast label. */
18402 
18403 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18404 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18405 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18406 
18407 #else
18408   /* Define argument-access macros assuming that fast branches are disabled. */
18409 #if defined(JITTER_DISPATCH_NO_THREADING)
18410 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
18411     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
18412 #elif defined (JITTER_REPLICATE)
18413 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
18414 #else
18415 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
18416 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
18417 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18418 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18419 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18420 #   define JITTER_ARGF0 JITTER_ARGP0
18421 
18422 # endif // #ifdef JITTER_HAVE_PATCH_IN
18423 
18424 #if defined (JITTER_PROFILE_SAMPLE)
18425   JITTER_PROFILE_SAMPLE_UPDATE
18426      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18427       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18428   /* Force the compiler not move sample-profiling instrumentation
18429      beyond this point; this way the actual user code is timed.
18430      This is still not perfect, as residuals are materialised before
18431      we arrive here, but should be adequate at least for slow VM
18432      instructions. */
18433   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18434 #endif
18435 #if defined (JITTER_PROFILE_COUNT)
18436   /* Notice that, differently from the code above, this
18437      instrumentation code *can* be reordered freely: as long as a
18438      VM instruction is counted, the count increment can be placed
18439      anyehere.  Let GCC move this code and possibly achieve better
18440      throughput by exploiting instruction-level parallelism and
18441      therefore approximate more closely a non-profiled build. */
18442   JITTER_PROFILE_COUNT_UPDATE
18443      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18444       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18445 #endif
18446 
18447 /* User-specified code, instruction-beginning-c part: beginning. */
18448 
18449 
18450 /* User-specified code, instruction-beginning-c part: end */
18451 
18452 
18453     /* User code for gc-if-needed/fR . */
18454 
18455 #ifdef JITTER_GC_STUB
18456     /* FIXME: I might want to merge this, along with the body of other
18457        instructions, into a macro.  This may still be factored in a different
18458        way, but the idea looks correct and promising. */
18459     /* Branch to the slow path of the allocation, which includes a minor GC,
18460        in case the allocation pointer is now out of the nursery.  Do nothing
18461        otherwise.
18462        Rationale: separating branches from instructions having effect on the VM
18463        state prevents defective instructions; even if I have reason to believe
18464        that this particular state effect (unconditionally incrementing a runtime
18465        field) is not problematic with respect to defects, I will need to seriously
18466        stress the system after defect replacement is really implemented. */
18467     JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18468        (JITTER_STATE_RUNTIME_FIELD (allocation_next),
18469         JITTER_STATE_RUNTIME_FIELD (allocation_limit),
18470         JITTER_ARGF0);
18471 #else
18472     /* Nothing to do.  With the ordinary non-stub heap all the actual
18473        memory allocation happens in primitive-cons-special. */
18474 #endif //#ifdef JITTER_GC_STUB
18475 
18476     /* End of the user code for gc-if-needed/fR . */
18477 
18478 /* User-specified code, instruction-end-c part: beginning. */
18479 
18480 
18481 /* User-specified code, instruction-end-c part: end */
18482 
18483     /* Undefine the gc-if-needed/fR argument macros so they can't be used
18484        by mistake in the instruction body coming next. */
18485 #   undef JITTER_SLOW_REGISTER_OFFSET0
18486 #   undef JITTER_ARG0
18487 #   undef JITTER_ARGN0
18488 #   undef JITTER_ARGU0
18489 #   undef JITTER_ARGP0
18490 #   undef JITTER_ARGF0
18491 
18492 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18493 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18494 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18495 
18496   }
18497  JITTER_INSTRUCTION_EPILOG_(gc-if-needed/fR, gc_mif_mneeded__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18498 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18499 
18500   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n4, heap_mallocate__n4, hot)
18501   {
18502     /* This specialized instruction is not a replacement. */
18503 #   undef JITTER_BRANCH_FAST
18504 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18505 #   undef JITTER_BRANCH_FAST_IF_ZERO
18506 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18507 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18508 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18509 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18510 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18511 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18512 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18513 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18514 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18515 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18516 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18517 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18518 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18519 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18520 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18521 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18522 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18523 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18524 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18525 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18526 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18527 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18528 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18529 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18530 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18531 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18532 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18533 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18534 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18535 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18536 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18537 #   undef JITTER_BRANCH_FAST_IF_AND
18538 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18539 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18540 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18541 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18542 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18543 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18544 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18545 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18546 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18547 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18548 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18549 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18550 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18551 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18552 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18553 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18554 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18555 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18556 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18557 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18558 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18559 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18560 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18561 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18562 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18563 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18564 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18565 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18566 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18567 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       87
18568 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n4
18569 
18570 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n4
18571 
18572   /* The residual arity for this instruction does not depend on fast labels. */
18573   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
18574 
18575     /* The 0th argument is a nonresidual literal. */
18576 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
18577 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18578 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18579 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18580 #   define JITTER_ARGF0 JITTER_ARGP0
18581 
18582 
18583 #if defined (JITTER_PROFILE_SAMPLE)
18584   JITTER_PROFILE_SAMPLE_UPDATE
18585      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18586       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18587   /* Force the compiler not move sample-profiling instrumentation
18588      beyond this point; this way the actual user code is timed.
18589      This is still not perfect, as residuals are materialised before
18590      we arrive here, but should be adequate at least for slow VM
18591      instructions. */
18592   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18593 #endif
18594 #if defined (JITTER_PROFILE_COUNT)
18595   /* Notice that, differently from the code above, this
18596      instrumentation code *can* be reordered freely: as long as a
18597      VM instruction is counted, the count increment can be placed
18598      anyehere.  Let GCC move this code and possibly achieve better
18599      throughput by exploiting instruction-level parallelism and
18600      therefore approximate more closely a non-profiled build. */
18601   JITTER_PROFILE_COUNT_UPDATE
18602      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18603       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18604 #endif
18605 
18606 /* User-specified code, instruction-beginning-c part: beginning. */
18607 
18608 
18609 /* User-specified code, instruction-beginning-c part: end */
18610 
18611 
18612     /* User code for heap-allocate/n4 . */
18613 
18614 #ifdef JITTER_GC_STUB
18615     /* FIXME: I might want to merge this, along with the body of other
18616        instructions, into a macro.  This may still be factored in a different
18617        way, but the idea looks correct and promising. */
18618     /* Bump the allocation pointer, unconditionally.  Another instruction
18619        will check if it went out of the nursery. */
18620     const size_t allocation_size = JITTER_ARGN0;
18621     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
18622 #else
18623     /* Nothing to do.  With the ordinary non-stub heap all the actual
18624        memory allocation happens in primitive-cons-special. */
18625 #endif //#ifdef JITTER_GC_STUB
18626 
18627     /* End of the user code for heap-allocate/n4 . */
18628 
18629 /* User-specified code, instruction-end-c part: beginning. */
18630 
18631 
18632 /* User-specified code, instruction-end-c part: end */
18633 
18634     /* Undefine the heap-allocate/n4 argument macros so they can't be used
18635        by mistake in the instruction body coming next. */
18636 #   undef JITTER_SLOW_REGISTER_OFFSET0
18637 #   undef JITTER_ARG0
18638 #   undef JITTER_ARGN0
18639 #   undef JITTER_ARGU0
18640 #   undef JITTER_ARGP0
18641 #   undef JITTER_ARGF0
18642 
18643 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18644 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18645 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18646 
18647   }
18648  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n4, heap_mallocate__n4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18649 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18650 
18651   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n8, heap_mallocate__n8, hot)
18652   {
18653     /* This specialized instruction is not a replacement. */
18654 #   undef JITTER_BRANCH_FAST
18655 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18656 #   undef JITTER_BRANCH_FAST_IF_ZERO
18657 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18658 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18659 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18660 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18661 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18662 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18663 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18664 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18665 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18666 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18667 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18668 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18669 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18670 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18671 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18672 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18673 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18674 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18675 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18676 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18677 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18678 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18679 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18680 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18681 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18682 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18683 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18684 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18685 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18686 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18687 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18688 #   undef JITTER_BRANCH_FAST_IF_AND
18689 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18690 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18691 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18692 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18693 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18694 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18695 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18696 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18697 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18698 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18699 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18700 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18701 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18702 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18703 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18704 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18705 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18706 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18707 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18708 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18709 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18710 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18711 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18712 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18713 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18714 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18715 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18716 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18717 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18718 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       88
18719 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n8
18720 
18721 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n8
18722 
18723   /* The residual arity for this instruction does not depend on fast labels. */
18724   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
18725 
18726     /* The 0th argument is a nonresidual literal. */
18727 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
18728 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18729 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18730 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18731 #   define JITTER_ARGF0 JITTER_ARGP0
18732 
18733 
18734 #if defined (JITTER_PROFILE_SAMPLE)
18735   JITTER_PROFILE_SAMPLE_UPDATE
18736      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18737       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18738   /* Force the compiler not move sample-profiling instrumentation
18739      beyond this point; this way the actual user code is timed.
18740      This is still not perfect, as residuals are materialised before
18741      we arrive here, but should be adequate at least for slow VM
18742      instructions. */
18743   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18744 #endif
18745 #if defined (JITTER_PROFILE_COUNT)
18746   /* Notice that, differently from the code above, this
18747      instrumentation code *can* be reordered freely: as long as a
18748      VM instruction is counted, the count increment can be placed
18749      anyehere.  Let GCC move this code and possibly achieve better
18750      throughput by exploiting instruction-level parallelism and
18751      therefore approximate more closely a non-profiled build. */
18752   JITTER_PROFILE_COUNT_UPDATE
18753      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18754       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18755 #endif
18756 
18757 /* User-specified code, instruction-beginning-c part: beginning. */
18758 
18759 
18760 /* User-specified code, instruction-beginning-c part: end */
18761 
18762 
18763     /* User code for heap-allocate/n8 . */
18764 
18765 #ifdef JITTER_GC_STUB
18766     /* FIXME: I might want to merge this, along with the body of other
18767        instructions, into a macro.  This may still be factored in a different
18768        way, but the idea looks correct and promising. */
18769     /* Bump the allocation pointer, unconditionally.  Another instruction
18770        will check if it went out of the nursery. */
18771     const size_t allocation_size = JITTER_ARGN0;
18772     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
18773 #else
18774     /* Nothing to do.  With the ordinary non-stub heap all the actual
18775        memory allocation happens in primitive-cons-special. */
18776 #endif //#ifdef JITTER_GC_STUB
18777 
18778     /* End of the user code for heap-allocate/n8 . */
18779 
18780 /* User-specified code, instruction-end-c part: beginning. */
18781 
18782 
18783 /* User-specified code, instruction-end-c part: end */
18784 
18785     /* Undefine the heap-allocate/n8 argument macros so they can't be used
18786        by mistake in the instruction body coming next. */
18787 #   undef JITTER_SLOW_REGISTER_OFFSET0
18788 #   undef JITTER_ARG0
18789 #   undef JITTER_ARGN0
18790 #   undef JITTER_ARGU0
18791 #   undef JITTER_ARGP0
18792 #   undef JITTER_ARGF0
18793 
18794 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18795 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18796 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18797 
18798   }
18799  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n8, heap_mallocate__n8, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18800 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18801 
18802   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n12, heap_mallocate__n12, hot)
18803   {
18804     /* This specialized instruction is not a replacement. */
18805 #   undef JITTER_BRANCH_FAST
18806 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18807 #   undef JITTER_BRANCH_FAST_IF_ZERO
18808 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18809 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18810 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18811 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18812 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18813 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18814 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18815 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18816 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18817 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18818 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18819 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18820 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18821 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18822 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18823 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18824 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18825 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18826 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18827 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18828 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18829 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18830 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18831 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18832 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18833 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18834 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18835 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18836 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18837 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18838 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18839 #   undef JITTER_BRANCH_FAST_IF_AND
18840 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18841 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18842 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18843 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18844 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18845 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18846 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18847 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18848 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18849 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18850 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
18851 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18852 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
18853 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18854 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
18855 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18856 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
18857 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18858 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
18859 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18860 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
18861 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18862 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
18863 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18864 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
18865 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18866 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
18867 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18868 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
18869 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       89
18870 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n12
18871 
18872 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n12
18873 
18874   /* The residual arity for this instruction does not depend on fast labels. */
18875   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
18876 
18877     /* The 0th argument is a nonresidual literal. */
18878 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 12L})
18879 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
18880 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
18881 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
18882 #   define JITTER_ARGF0 JITTER_ARGP0
18883 
18884 
18885 #if defined (JITTER_PROFILE_SAMPLE)
18886   JITTER_PROFILE_SAMPLE_UPDATE
18887      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18888       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18889   /* Force the compiler not move sample-profiling instrumentation
18890      beyond this point; this way the actual user code is timed.
18891      This is still not perfect, as residuals are materialised before
18892      we arrive here, but should be adequate at least for slow VM
18893      instructions. */
18894   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
18895 #endif
18896 #if defined (JITTER_PROFILE_COUNT)
18897   /* Notice that, differently from the code above, this
18898      instrumentation code *can* be reordered freely: as long as a
18899      VM instruction is counted, the count increment can be placed
18900      anyehere.  Let GCC move this code and possibly achieve better
18901      throughput by exploiting instruction-level parallelism and
18902      therefore approximate more closely a non-profiled build. */
18903   JITTER_PROFILE_COUNT_UPDATE
18904      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
18905       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
18906 #endif
18907 
18908 /* User-specified code, instruction-beginning-c part: beginning. */
18909 
18910 
18911 /* User-specified code, instruction-beginning-c part: end */
18912 
18913 
18914     /* User code for heap-allocate/n12 . */
18915 
18916 #ifdef JITTER_GC_STUB
18917     /* FIXME: I might want to merge this, along with the body of other
18918        instructions, into a macro.  This may still be factored in a different
18919        way, but the idea looks correct and promising. */
18920     /* Bump the allocation pointer, unconditionally.  Another instruction
18921        will check if it went out of the nursery. */
18922     const size_t allocation_size = JITTER_ARGN0;
18923     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
18924 #else
18925     /* Nothing to do.  With the ordinary non-stub heap all the actual
18926        memory allocation happens in primitive-cons-special. */
18927 #endif //#ifdef JITTER_GC_STUB
18928 
18929     /* End of the user code for heap-allocate/n12 . */
18930 
18931 /* User-specified code, instruction-end-c part: beginning. */
18932 
18933 
18934 /* User-specified code, instruction-end-c part: end */
18935 
18936     /* Undefine the heap-allocate/n12 argument macros so they can't be used
18937        by mistake in the instruction body coming next. */
18938 #   undef JITTER_SLOW_REGISTER_OFFSET0
18939 #   undef JITTER_ARG0
18940 #   undef JITTER_ARGN0
18941 #   undef JITTER_ARGU0
18942 #   undef JITTER_ARGP0
18943 #   undef JITTER_ARGF0
18944 
18945 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
18946 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
18947 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
18948 
18949   }
18950  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n12, heap_mallocate__n12, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
18951 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
18952 
18953   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n16, heap_mallocate__n16, hot)
18954   {
18955     /* This specialized instruction is not a replacement. */
18956 #   undef JITTER_BRANCH_FAST
18957 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
18958 #   undef JITTER_BRANCH_FAST_IF_ZERO
18959 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
18960 #   undef JITTER_BRANCH_FAST_IF_NONZERO
18961 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
18962 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
18963 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
18964 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
18965 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
18966 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
18967 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
18968 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
18969 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
18970 #   undef JITTER_BRANCH_FAST_IF_EQUAL
18971 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
18972 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
18973 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
18974 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
18975 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
18976 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18977 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
18978 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18979 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
18980 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18981 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
18982 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18983 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
18984 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18985 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
18986 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18987 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
18988 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18989 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
18990 #   undef JITTER_BRANCH_FAST_IF_AND
18991 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
18992 #   undef JITTER_BRANCH_FAST_IF_NOTAND
18993 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
18994 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18995 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
18996 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18997 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
18998 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
18999 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19000 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19001 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19002 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19003 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19004 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19005 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19006 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19007 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19008 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19009 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19010 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19011 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19012 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19013 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19014 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19015 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19016 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19017 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19018 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19019 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19020 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       90
19021 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n16
19022 
19023 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n16
19024 
19025   /* The residual arity for this instruction does not depend on fast labels. */
19026   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19027 
19028     /* The 0th argument is a nonresidual literal. */
19029 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 16L})
19030 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19031 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19032 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19033 #   define JITTER_ARGF0 JITTER_ARGP0
19034 
19035 
19036 #if defined (JITTER_PROFILE_SAMPLE)
19037   JITTER_PROFILE_SAMPLE_UPDATE
19038      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19039       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19040   /* Force the compiler not move sample-profiling instrumentation
19041      beyond this point; this way the actual user code is timed.
19042      This is still not perfect, as residuals are materialised before
19043      we arrive here, but should be adequate at least for slow VM
19044      instructions. */
19045   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19046 #endif
19047 #if defined (JITTER_PROFILE_COUNT)
19048   /* Notice that, differently from the code above, this
19049      instrumentation code *can* be reordered freely: as long as a
19050      VM instruction is counted, the count increment can be placed
19051      anyehere.  Let GCC move this code and possibly achieve better
19052      throughput by exploiting instruction-level parallelism and
19053      therefore approximate more closely a non-profiled build. */
19054   JITTER_PROFILE_COUNT_UPDATE
19055      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19056       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19057 #endif
19058 
19059 /* User-specified code, instruction-beginning-c part: beginning. */
19060 
19061 
19062 /* User-specified code, instruction-beginning-c part: end */
19063 
19064 
19065     /* User code for heap-allocate/n16 . */
19066 
19067 #ifdef JITTER_GC_STUB
19068     /* FIXME: I might want to merge this, along with the body of other
19069        instructions, into a macro.  This may still be factored in a different
19070        way, but the idea looks correct and promising. */
19071     /* Bump the allocation pointer, unconditionally.  Another instruction
19072        will check if it went out of the nursery. */
19073     const size_t allocation_size = JITTER_ARGN0;
19074     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
19075 #else
19076     /* Nothing to do.  With the ordinary non-stub heap all the actual
19077        memory allocation happens in primitive-cons-special. */
19078 #endif //#ifdef JITTER_GC_STUB
19079 
19080     /* End of the user code for heap-allocate/n16 . */
19081 
19082 /* User-specified code, instruction-end-c part: beginning. */
19083 
19084 
19085 /* User-specified code, instruction-end-c part: end */
19086 
19087     /* Undefine the heap-allocate/n16 argument macros so they can't be used
19088        by mistake in the instruction body coming next. */
19089 #   undef JITTER_SLOW_REGISTER_OFFSET0
19090 #   undef JITTER_ARG0
19091 #   undef JITTER_ARGN0
19092 #   undef JITTER_ARGU0
19093 #   undef JITTER_ARGP0
19094 #   undef JITTER_ARGF0
19095 
19096 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19097 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19098 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19099 
19100   }
19101  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n16, heap_mallocate__n16, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19102 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19103 
19104   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n24, heap_mallocate__n24, hot)
19105   {
19106     /* This specialized instruction is not a replacement. */
19107 #   undef JITTER_BRANCH_FAST
19108 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19109 #   undef JITTER_BRANCH_FAST_IF_ZERO
19110 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19111 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19112 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19113 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19114 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19115 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19116 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19117 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19118 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19119 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19120 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19121 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19122 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19123 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19124 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19125 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19126 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19127 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19128 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19129 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19130 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19131 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19132 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19133 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19134 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19135 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19136 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19137 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19138 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19139 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19140 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19141 #   undef JITTER_BRANCH_FAST_IF_AND
19142 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19143 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19144 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19145 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19146 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19147 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19148 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19149 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19150 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19151 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19152 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19153 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19154 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19155 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19156 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19157 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19158 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19159 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19160 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19161 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19162 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19163 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19164 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19165 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19166 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19167 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19168 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19169 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19170 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19171 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       91
19172 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n24
19173 
19174 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n24
19175 
19176   /* The residual arity for this instruction does not depend on fast labels. */
19177   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19178 
19179     /* The 0th argument is a nonresidual literal. */
19180 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 24L})
19181 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19182 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19183 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19184 #   define JITTER_ARGF0 JITTER_ARGP0
19185 
19186 
19187 #if defined (JITTER_PROFILE_SAMPLE)
19188   JITTER_PROFILE_SAMPLE_UPDATE
19189      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19190       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19191   /* Force the compiler not move sample-profiling instrumentation
19192      beyond this point; this way the actual user code is timed.
19193      This is still not perfect, as residuals are materialised before
19194      we arrive here, but should be adequate at least for slow VM
19195      instructions. */
19196   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19197 #endif
19198 #if defined (JITTER_PROFILE_COUNT)
19199   /* Notice that, differently from the code above, this
19200      instrumentation code *can* be reordered freely: as long as a
19201      VM instruction is counted, the count increment can be placed
19202      anyehere.  Let GCC move this code and possibly achieve better
19203      throughput by exploiting instruction-level parallelism and
19204      therefore approximate more closely a non-profiled build. */
19205   JITTER_PROFILE_COUNT_UPDATE
19206      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19207       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19208 #endif
19209 
19210 /* User-specified code, instruction-beginning-c part: beginning. */
19211 
19212 
19213 /* User-specified code, instruction-beginning-c part: end */
19214 
19215 
19216     /* User code for heap-allocate/n24 . */
19217 
19218 #ifdef JITTER_GC_STUB
19219     /* FIXME: I might want to merge this, along with the body of other
19220        instructions, into a macro.  This may still be factored in a different
19221        way, but the idea looks correct and promising. */
19222     /* Bump the allocation pointer, unconditionally.  Another instruction
19223        will check if it went out of the nursery. */
19224     const size_t allocation_size = JITTER_ARGN0;
19225     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
19226 #else
19227     /* Nothing to do.  With the ordinary non-stub heap all the actual
19228        memory allocation happens in primitive-cons-special. */
19229 #endif //#ifdef JITTER_GC_STUB
19230 
19231     /* End of the user code for heap-allocate/n24 . */
19232 
19233 /* User-specified code, instruction-end-c part: beginning. */
19234 
19235 
19236 /* User-specified code, instruction-end-c part: end */
19237 
19238     /* Undefine the heap-allocate/n24 argument macros so they can't be used
19239        by mistake in the instruction body coming next. */
19240 #   undef JITTER_SLOW_REGISTER_OFFSET0
19241 #   undef JITTER_ARG0
19242 #   undef JITTER_ARGN0
19243 #   undef JITTER_ARGU0
19244 #   undef JITTER_ARGP0
19245 #   undef JITTER_ARGF0
19246 
19247 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19248 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19249 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19250 
19251   }
19252  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n24, heap_mallocate__n24, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19253 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19254 
19255   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n32, heap_mallocate__n32, hot)
19256   {
19257     /* This specialized instruction is not a replacement. */
19258 #   undef JITTER_BRANCH_FAST
19259 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19260 #   undef JITTER_BRANCH_FAST_IF_ZERO
19261 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19262 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19263 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19264 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19265 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19266 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19267 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19268 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19269 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19270 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19271 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19272 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19273 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19274 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19275 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19276 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19277 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19278 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19279 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19280 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19281 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19282 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19283 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19284 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19285 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19286 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19287 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19288 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19289 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19290 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19291 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19292 #   undef JITTER_BRANCH_FAST_IF_AND
19293 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19294 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19295 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19296 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19297 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19298 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19299 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19300 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19301 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19302 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19303 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19304 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19305 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19306 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19307 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19308 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19309 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19310 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19311 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19312 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19313 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19314 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19315 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19316 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19317 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19318 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19319 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19320 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19321 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19322 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       92
19323 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n32
19324 
19325 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n32
19326 
19327   /* The residual arity for this instruction does not depend on fast labels. */
19328   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19329 
19330     /* The 0th argument is a nonresidual literal. */
19331 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 32L})
19332 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19333 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19334 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19335 #   define JITTER_ARGF0 JITTER_ARGP0
19336 
19337 
19338 #if defined (JITTER_PROFILE_SAMPLE)
19339   JITTER_PROFILE_SAMPLE_UPDATE
19340      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19341       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19342   /* Force the compiler not move sample-profiling instrumentation
19343      beyond this point; this way the actual user code is timed.
19344      This is still not perfect, as residuals are materialised before
19345      we arrive here, but should be adequate at least for slow VM
19346      instructions. */
19347   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19348 #endif
19349 #if defined (JITTER_PROFILE_COUNT)
19350   /* Notice that, differently from the code above, this
19351      instrumentation code *can* be reordered freely: as long as a
19352      VM instruction is counted, the count increment can be placed
19353      anyehere.  Let GCC move this code and possibly achieve better
19354      throughput by exploiting instruction-level parallelism and
19355      therefore approximate more closely a non-profiled build. */
19356   JITTER_PROFILE_COUNT_UPDATE
19357      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19358       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19359 #endif
19360 
19361 /* User-specified code, instruction-beginning-c part: beginning. */
19362 
19363 
19364 /* User-specified code, instruction-beginning-c part: end */
19365 
19366 
19367     /* User code for heap-allocate/n32 . */
19368 
19369 #ifdef JITTER_GC_STUB
19370     /* FIXME: I might want to merge this, along with the body of other
19371        instructions, into a macro.  This may still be factored in a different
19372        way, but the idea looks correct and promising. */
19373     /* Bump the allocation pointer, unconditionally.  Another instruction
19374        will check if it went out of the nursery. */
19375     const size_t allocation_size = JITTER_ARGN0;
19376     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
19377 #else
19378     /* Nothing to do.  With the ordinary non-stub heap all the actual
19379        memory allocation happens in primitive-cons-special. */
19380 #endif //#ifdef JITTER_GC_STUB
19381 
19382     /* End of the user code for heap-allocate/n32 . */
19383 
19384 /* User-specified code, instruction-end-c part: beginning. */
19385 
19386 
19387 /* User-specified code, instruction-end-c part: end */
19388 
19389     /* Undefine the heap-allocate/n32 argument macros so they can't be used
19390        by mistake in the instruction body coming next. */
19391 #   undef JITTER_SLOW_REGISTER_OFFSET0
19392 #   undef JITTER_ARG0
19393 #   undef JITTER_ARGN0
19394 #   undef JITTER_ARGU0
19395 #   undef JITTER_ARGP0
19396 #   undef JITTER_ARGF0
19397 
19398 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19399 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19400 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19401 
19402   }
19403  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n32, heap_mallocate__n32, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19404 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19405 
19406   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n36, heap_mallocate__n36, hot)
19407   {
19408     /* This specialized instruction is not a replacement. */
19409 #   undef JITTER_BRANCH_FAST
19410 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19411 #   undef JITTER_BRANCH_FAST_IF_ZERO
19412 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19413 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19414 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19415 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19416 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19417 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19418 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19419 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19420 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19421 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19422 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19423 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19424 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19425 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19426 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19427 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19428 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19429 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19430 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19431 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19432 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19433 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19434 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19435 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19436 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19437 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19438 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19439 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19440 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19441 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19442 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19443 #   undef JITTER_BRANCH_FAST_IF_AND
19444 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19445 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19446 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19447 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19448 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19449 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19450 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19451 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19452 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19453 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19454 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19455 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19456 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19457 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19458 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19459 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19460 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19461 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19462 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19463 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19464 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19465 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19466 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19467 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19468 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19469 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19470 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19471 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19472 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19473 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       93
19474 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n36
19475 
19476 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n36
19477 
19478   /* The residual arity for this instruction does not depend on fast labels. */
19479   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19480 
19481     /* The 0th argument is a nonresidual literal. */
19482 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 36L})
19483 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19484 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19485 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19486 #   define JITTER_ARGF0 JITTER_ARGP0
19487 
19488 
19489 #if defined (JITTER_PROFILE_SAMPLE)
19490   JITTER_PROFILE_SAMPLE_UPDATE
19491      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19492       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19493   /* Force the compiler not move sample-profiling instrumentation
19494      beyond this point; this way the actual user code is timed.
19495      This is still not perfect, as residuals are materialised before
19496      we arrive here, but should be adequate at least for slow VM
19497      instructions. */
19498   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19499 #endif
19500 #if defined (JITTER_PROFILE_COUNT)
19501   /* Notice that, differently from the code above, this
19502      instrumentation code *can* be reordered freely: as long as a
19503      VM instruction is counted, the count increment can be placed
19504      anyehere.  Let GCC move this code and possibly achieve better
19505      throughput by exploiting instruction-level parallelism and
19506      therefore approximate more closely a non-profiled build. */
19507   JITTER_PROFILE_COUNT_UPDATE
19508      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19509       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19510 #endif
19511 
19512 /* User-specified code, instruction-beginning-c part: beginning. */
19513 
19514 
19515 /* User-specified code, instruction-beginning-c part: end */
19516 
19517 
19518     /* User code for heap-allocate/n36 . */
19519 
19520 #ifdef JITTER_GC_STUB
19521     /* FIXME: I might want to merge this, along with the body of other
19522        instructions, into a macro.  This may still be factored in a different
19523        way, but the idea looks correct and promising. */
19524     /* Bump the allocation pointer, unconditionally.  Another instruction
19525        will check if it went out of the nursery. */
19526     const size_t allocation_size = JITTER_ARGN0;
19527     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
19528 #else
19529     /* Nothing to do.  With the ordinary non-stub heap all the actual
19530        memory allocation happens in primitive-cons-special. */
19531 #endif //#ifdef JITTER_GC_STUB
19532 
19533     /* End of the user code for heap-allocate/n36 . */
19534 
19535 /* User-specified code, instruction-end-c part: beginning. */
19536 
19537 
19538 /* User-specified code, instruction-end-c part: end */
19539 
19540     /* Undefine the heap-allocate/n36 argument macros so they can't be used
19541        by mistake in the instruction body coming next. */
19542 #   undef JITTER_SLOW_REGISTER_OFFSET0
19543 #   undef JITTER_ARG0
19544 #   undef JITTER_ARGN0
19545 #   undef JITTER_ARGU0
19546 #   undef JITTER_ARGP0
19547 #   undef JITTER_ARGF0
19548 
19549 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19550 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19551 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19552 
19553   }
19554  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n36, heap_mallocate__n36, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19555 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19556 
19557   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n48, heap_mallocate__n48, hot)
19558   {
19559     /* This specialized instruction is not a replacement. */
19560 #   undef JITTER_BRANCH_FAST
19561 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19562 #   undef JITTER_BRANCH_FAST_IF_ZERO
19563 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19564 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19565 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19566 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19567 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19568 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19569 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19570 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19571 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19572 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19573 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19574 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19575 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19576 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19577 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19578 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19579 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19580 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19581 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19582 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19583 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19584 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19585 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19586 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19587 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19588 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19589 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19590 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19591 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19592 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19593 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19594 #   undef JITTER_BRANCH_FAST_IF_AND
19595 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19596 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19597 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19598 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19599 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19600 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19601 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19602 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19603 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19604 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19605 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19606 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19607 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19608 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19609 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19610 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19611 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19612 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19613 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19614 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19615 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19616 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19617 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19618 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19619 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19620 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19621 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19622 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19623 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19624 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       94
19625 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n48
19626 
19627 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n48
19628 
19629   /* The residual arity for this instruction does not depend on fast labels. */
19630   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19631 
19632     /* The 0th argument is a nonresidual literal. */
19633 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 48L})
19634 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19635 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19636 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19637 #   define JITTER_ARGF0 JITTER_ARGP0
19638 
19639 
19640 #if defined (JITTER_PROFILE_SAMPLE)
19641   JITTER_PROFILE_SAMPLE_UPDATE
19642      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19643       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19644   /* Force the compiler not move sample-profiling instrumentation
19645      beyond this point; this way the actual user code is timed.
19646      This is still not perfect, as residuals are materialised before
19647      we arrive here, but should be adequate at least for slow VM
19648      instructions. */
19649   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19650 #endif
19651 #if defined (JITTER_PROFILE_COUNT)
19652   /* Notice that, differently from the code above, this
19653      instrumentation code *can* be reordered freely: as long as a
19654      VM instruction is counted, the count increment can be placed
19655      anyehere.  Let GCC move this code and possibly achieve better
19656      throughput by exploiting instruction-level parallelism and
19657      therefore approximate more closely a non-profiled build. */
19658   JITTER_PROFILE_COUNT_UPDATE
19659      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19660       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19661 #endif
19662 
19663 /* User-specified code, instruction-beginning-c part: beginning. */
19664 
19665 
19666 /* User-specified code, instruction-beginning-c part: end */
19667 
19668 
19669     /* User code for heap-allocate/n48 . */
19670 
19671 #ifdef JITTER_GC_STUB
19672     /* FIXME: I might want to merge this, along with the body of other
19673        instructions, into a macro.  This may still be factored in a different
19674        way, but the idea looks correct and promising. */
19675     /* Bump the allocation pointer, unconditionally.  Another instruction
19676        will check if it went out of the nursery. */
19677     const size_t allocation_size = JITTER_ARGN0;
19678     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
19679 #else
19680     /* Nothing to do.  With the ordinary non-stub heap all the actual
19681        memory allocation happens in primitive-cons-special. */
19682 #endif //#ifdef JITTER_GC_STUB
19683 
19684     /* End of the user code for heap-allocate/n48 . */
19685 
19686 /* User-specified code, instruction-end-c part: beginning. */
19687 
19688 
19689 /* User-specified code, instruction-end-c part: end */
19690 
19691     /* Undefine the heap-allocate/n48 argument macros so they can't be used
19692        by mistake in the instruction body coming next. */
19693 #   undef JITTER_SLOW_REGISTER_OFFSET0
19694 #   undef JITTER_ARG0
19695 #   undef JITTER_ARGN0
19696 #   undef JITTER_ARGU0
19697 #   undef JITTER_ARGP0
19698 #   undef JITTER_ARGF0
19699 
19700 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19701 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19702 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19703 
19704   }
19705  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n48, heap_mallocate__n48, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19706 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19707 
19708   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n52, heap_mallocate__n52, hot)
19709   {
19710     /* This specialized instruction is not a replacement. */
19711 #   undef JITTER_BRANCH_FAST
19712 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19713 #   undef JITTER_BRANCH_FAST_IF_ZERO
19714 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19715 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19716 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19717 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19718 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19719 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19720 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19721 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19722 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19723 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19724 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19725 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19726 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19727 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19728 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19729 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19730 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19731 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19732 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19733 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19734 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19735 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19736 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19737 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19738 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19739 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19740 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19741 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19742 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19743 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19744 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19745 #   undef JITTER_BRANCH_FAST_IF_AND
19746 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19747 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19748 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19749 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19750 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19751 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19752 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19753 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19754 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19755 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19756 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19757 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19758 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19759 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19760 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19761 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19762 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19763 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19764 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19765 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19766 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19767 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19768 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19769 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19770 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19771 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19772 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19773 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19774 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19775 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       95
19776 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n52
19777 
19778 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n52
19779 
19780   /* The residual arity for this instruction does not depend on fast labels. */
19781   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19782 
19783     /* The 0th argument is a nonresidual literal. */
19784 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 52L})
19785 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19786 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19787 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19788 #   define JITTER_ARGF0 JITTER_ARGP0
19789 
19790 
19791 #if defined (JITTER_PROFILE_SAMPLE)
19792   JITTER_PROFILE_SAMPLE_UPDATE
19793      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19794       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19795   /* Force the compiler not move sample-profiling instrumentation
19796      beyond this point; this way the actual user code is timed.
19797      This is still not perfect, as residuals are materialised before
19798      we arrive here, but should be adequate at least for slow VM
19799      instructions. */
19800   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19801 #endif
19802 #if defined (JITTER_PROFILE_COUNT)
19803   /* Notice that, differently from the code above, this
19804      instrumentation code *can* be reordered freely: as long as a
19805      VM instruction is counted, the count increment can be placed
19806      anyehere.  Let GCC move this code and possibly achieve better
19807      throughput by exploiting instruction-level parallelism and
19808      therefore approximate more closely a non-profiled build. */
19809   JITTER_PROFILE_COUNT_UPDATE
19810      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19811       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19812 #endif
19813 
19814 /* User-specified code, instruction-beginning-c part: beginning. */
19815 
19816 
19817 /* User-specified code, instruction-beginning-c part: end */
19818 
19819 
19820     /* User code for heap-allocate/n52 . */
19821 
19822 #ifdef JITTER_GC_STUB
19823     /* FIXME: I might want to merge this, along with the body of other
19824        instructions, into a macro.  This may still be factored in a different
19825        way, but the idea looks correct and promising. */
19826     /* Bump the allocation pointer, unconditionally.  Another instruction
19827        will check if it went out of the nursery. */
19828     const size_t allocation_size = JITTER_ARGN0;
19829     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
19830 #else
19831     /* Nothing to do.  With the ordinary non-stub heap all the actual
19832        memory allocation happens in primitive-cons-special. */
19833 #endif //#ifdef JITTER_GC_STUB
19834 
19835     /* End of the user code for heap-allocate/n52 . */
19836 
19837 /* User-specified code, instruction-end-c part: beginning. */
19838 
19839 
19840 /* User-specified code, instruction-end-c part: end */
19841 
19842     /* Undefine the heap-allocate/n52 argument macros so they can't be used
19843        by mistake in the instruction body coming next. */
19844 #   undef JITTER_SLOW_REGISTER_OFFSET0
19845 #   undef JITTER_ARG0
19846 #   undef JITTER_ARGN0
19847 #   undef JITTER_ARGU0
19848 #   undef JITTER_ARGP0
19849 #   undef JITTER_ARGF0
19850 
19851 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
19852 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
19853 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
19854 
19855   }
19856  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n52, heap_mallocate__n52, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
19857 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
19858 
19859   JITTER_INSTRUCTION_PROLOG_(heap-allocate/n64, heap_mallocate__n64, hot)
19860   {
19861     /* This specialized instruction is not a replacement. */
19862 #   undef JITTER_BRANCH_FAST
19863 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
19864 #   undef JITTER_BRANCH_FAST_IF_ZERO
19865 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
19866 #   undef JITTER_BRANCH_FAST_IF_NONZERO
19867 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
19868 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
19869 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
19870 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
19871 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
19872 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
19873 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
19874 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
19875 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
19876 #   undef JITTER_BRANCH_FAST_IF_EQUAL
19877 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
19878 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
19879 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
19880 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
19881 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
19882 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19883 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
19884 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19885 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
19886 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19887 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
19888 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19889 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
19890 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19891 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
19892 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19893 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
19894 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19895 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
19896 #   undef JITTER_BRANCH_FAST_IF_AND
19897 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
19898 #   undef JITTER_BRANCH_FAST_IF_NOTAND
19899 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
19900 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19901 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
19902 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19903 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
19904 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19905 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
19906 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19907 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
19908 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19909 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
19910 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19911 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
19912 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19913 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
19914 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19915 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
19916 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19917 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
19918 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19919 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
19920 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19921 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
19922 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19923 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
19924 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19925 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
19926 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       96
19927 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/n64
19928 
19929 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__n64
19930 
19931   /* The residual arity for this instruction does not depend on fast labels. */
19932   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
19933 
19934     /* The 0th argument is a nonresidual literal. */
19935 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 64L})
19936 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
19937 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
19938 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
19939 #   define JITTER_ARGF0 JITTER_ARGP0
19940 
19941 
19942 #if defined (JITTER_PROFILE_SAMPLE)
19943   JITTER_PROFILE_SAMPLE_UPDATE
19944      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19945       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19946   /* Force the compiler not move sample-profiling instrumentation
19947      beyond this point; this way the actual user code is timed.
19948      This is still not perfect, as residuals are materialised before
19949      we arrive here, but should be adequate at least for slow VM
19950      instructions. */
19951   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
19952 #endif
19953 #if defined (JITTER_PROFILE_COUNT)
19954   /* Notice that, differently from the code above, this
19955      instrumentation code *can* be reordered freely: as long as a
19956      VM instruction is counted, the count increment can be placed
19957      anyehere.  Let GCC move this code and possibly achieve better
19958      throughput by exploiting instruction-level parallelism and
19959      therefore approximate more closely a non-profiled build. */
19960   JITTER_PROFILE_COUNT_UPDATE
19961      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
19962       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
19963 #endif
19964 
19965 /* User-specified code, instruction-beginning-c part: beginning. */
19966 
19967 
19968 /* User-specified code, instruction-beginning-c part: end */
19969 
19970 
19971     /* User code for heap-allocate/n64 . */
19972 
19973 #ifdef JITTER_GC_STUB
19974     /* FIXME: I might want to merge this, along with the body of other
19975        instructions, into a macro.  This may still be factored in a different
19976        way, but the idea looks correct and promising. */
19977     /* Bump the allocation pointer, unconditionally.  Another instruction
19978        will check if it went out of the nursery. */
19979     const size_t allocation_size = JITTER_ARGN0;
19980     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
19981 #else
19982     /* Nothing to do.  With the ordinary non-stub heap all the actual
19983        memory allocation happens in primitive-cons-special. */
19984 #endif //#ifdef JITTER_GC_STUB
19985 
19986     /* End of the user code for heap-allocate/n64 . */
19987 
19988 /* User-specified code, instruction-end-c part: beginning. */
19989 
19990 
19991 /* User-specified code, instruction-end-c part: end */
19992 
19993     /* Undefine the heap-allocate/n64 argument macros so they can't be used
19994        by mistake in the instruction body coming next. */
19995 #   undef JITTER_SLOW_REGISTER_OFFSET0
19996 #   undef JITTER_ARG0
19997 #   undef JITTER_ARGN0
19998 #   undef JITTER_ARGU0
19999 #   undef JITTER_ARGP0
20000 #   undef JITTER_ARGF0
20001 
20002 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20003 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20004 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20005 
20006   }
20007  JITTER_INSTRUCTION_EPILOG_(heap-allocate/n64, heap_mallocate__n64, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20008 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20009 
20010   JITTER_INSTRUCTION_PROLOG_(heap-allocate/nR, heap_mallocate__nR, cold)
20011   {
20012     /* This specialized instruction is not a replacement. */
20013 #   undef JITTER_BRANCH_FAST
20014 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20015 #   undef JITTER_BRANCH_FAST_IF_ZERO
20016 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20017 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20018 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20019 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20020 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20021 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20022 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20023 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20024 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20025 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20026 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20027 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20028 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20029 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20030 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20031 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20032 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20033 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20034 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20035 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20036 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20037 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20038 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20039 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20040 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20041 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20042 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20043 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20044 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20045 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20046 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20047 #   undef JITTER_BRANCH_FAST_IF_AND
20048 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20049 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20050 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20051 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20052 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20053 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20054 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20055 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20056 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20057 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20058 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20059 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20060 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20061 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20062 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20063 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20064 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20065 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20066 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20067 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20068 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20069 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20070 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20071 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20072 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20073 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20074 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20075 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20076 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20077 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       97
20078 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         heap-allocate/nR
20079 
20080 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME heap_mallocate__nR
20081 
20082   /* The residual arity for this instruction does not depend on fast labels. */
20083   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
20084 
20085     /* The 0th argument is a residual literal. */
20086 #if defined(JITTER_DISPATCH_NO_THREADING)
20087 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
20088     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
20089 #elif defined (JITTER_REPLICATE)
20090 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
20091 #else
20092 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
20093 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
20094 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
20095 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
20096 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
20097 #   define JITTER_ARGF0 JITTER_ARGP0
20098 
20099 
20100 #if defined (JITTER_PROFILE_SAMPLE)
20101   JITTER_PROFILE_SAMPLE_UPDATE
20102      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20103       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20104   /* Force the compiler not move sample-profiling instrumentation
20105      beyond this point; this way the actual user code is timed.
20106      This is still not perfect, as residuals are materialised before
20107      we arrive here, but should be adequate at least for slow VM
20108      instructions. */
20109   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20110 #endif
20111 #if defined (JITTER_PROFILE_COUNT)
20112   /* Notice that, differently from the code above, this
20113      instrumentation code *can* be reordered freely: as long as a
20114      VM instruction is counted, the count increment can be placed
20115      anyehere.  Let GCC move this code and possibly achieve better
20116      throughput by exploiting instruction-level parallelism and
20117      therefore approximate more closely a non-profiled build. */
20118   JITTER_PROFILE_COUNT_UPDATE
20119      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20120       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20121 #endif
20122 
20123 /* User-specified code, instruction-beginning-c part: beginning. */
20124 
20125 
20126 /* User-specified code, instruction-beginning-c part: end */
20127 
20128 
20129     /* User code for heap-allocate/nR . */
20130 
20131 #ifdef JITTER_GC_STUB
20132     /* FIXME: I might want to merge this, along with the body of other
20133        instructions, into a macro.  This may still be factored in a different
20134        way, but the idea looks correct and promising. */
20135     /* Bump the allocation pointer, unconditionally.  Another instruction
20136        will check if it went out of the nursery. */
20137     const size_t allocation_size = JITTER_ARGN0;
20138     JITTER_STATE_RUNTIME_FIELD (allocation_next) += allocation_size;
20139 #else
20140     /* Nothing to do.  With the ordinary non-stub heap all the actual
20141        memory allocation happens in primitive-cons-special. */
20142 #endif //#ifdef JITTER_GC_STUB
20143 
20144     /* End of the user code for heap-allocate/nR . */
20145 
20146 /* User-specified code, instruction-end-c part: beginning. */
20147 
20148 
20149 /* User-specified code, instruction-end-c part: end */
20150 
20151     /* Undefine the heap-allocate/nR argument macros so they can't be used
20152        by mistake in the instruction body coming next. */
20153 #   undef JITTER_SLOW_REGISTER_OFFSET0
20154 #   undef JITTER_ARG0
20155 #   undef JITTER_ARGN0
20156 #   undef JITTER_ARGU0
20157 #   undef JITTER_ARGP0
20158 #   undef JITTER_ARGF0
20159 
20160 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20161 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20162 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20163 
20164   }
20165  JITTER_INSTRUCTION_EPILOG_(heap-allocate/nR, heap_mallocate__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20166 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20167 
20168   JITTER_INSTRUCTION_PROLOG_(literal-to-register/nR/%rR, literal_mto_mregister__nR___rrR, cold)
20169   {
20170     /* This specialized instruction is not a replacement. */
20171 #   undef JITTER_BRANCH_FAST
20172 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20173 #   undef JITTER_BRANCH_FAST_IF_ZERO
20174 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20175 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20176 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20177 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20178 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20179 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20180 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20181 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20182 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20183 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20184 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20185 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20186 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20187 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20188 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20189 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20190 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20191 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20192 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20193 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20194 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20195 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20196 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20197 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20198 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20199 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20200 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20201 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20202 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20203 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20204 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20205 #   undef JITTER_BRANCH_FAST_IF_AND
20206 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20207 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20208 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20209 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20210 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20211 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20212 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20213 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20214 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20215 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20216 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20217 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20218 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20219 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20220 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20221 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20222 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20223 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20224 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20225 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20226 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20227 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20228 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20229 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20230 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20231 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20232 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20233 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20234 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20235 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       98
20236 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         literal-to-register/nR/%rR
20237 
20238 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME literal_mto_mregister__nR___rrR
20239 
20240   /* The residual arity for this instruction does not depend on fast labels. */
20241   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
20242 
20243     /* The 0th argument is a residual literal. */
20244 #if defined(JITTER_DISPATCH_NO_THREADING)
20245 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
20246     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
20247 #elif defined (JITTER_REPLICATE)
20248 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
20249 #else
20250 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
20251 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
20252 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
20253 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
20254 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
20255 #   define JITTER_ARGF0 JITTER_ARGP0
20256 
20257     /* The 1th argument is a slow (therefore residual, passed as an offset)
20258         register. */
20259   /* Define a macro expanding to the slow register offset. */
20260 #if defined(JITTER_DISPATCH_NO_THREADING)
20261 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
20262 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
20263 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
20264 #else
20265 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
20266 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
20267   /* Define a macro expanding to an l-value for the VM register content. */
20268 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
20269 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
20270 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
20271 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
20272 #   define JITTER_ARGF1 JITTER_ARGP1
20273 
20274 
20275 #if defined (JITTER_PROFILE_SAMPLE)
20276   JITTER_PROFILE_SAMPLE_UPDATE
20277      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20278       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20279   /* Force the compiler not move sample-profiling instrumentation
20280      beyond this point; this way the actual user code is timed.
20281      This is still not perfect, as residuals are materialised before
20282      we arrive here, but should be adequate at least for slow VM
20283      instructions. */
20284   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20285 #endif
20286 #if defined (JITTER_PROFILE_COUNT)
20287   /* Notice that, differently from the code above, this
20288      instrumentation code *can* be reordered freely: as long as a
20289      VM instruction is counted, the count increment can be placed
20290      anyehere.  Let GCC move this code and possibly achieve better
20291      throughput by exploiting instruction-level parallelism and
20292      therefore approximate more closely a non-profiled build. */
20293   JITTER_PROFILE_COUNT_UPDATE
20294      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20295       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20296 #endif
20297 
20298 /* User-specified code, instruction-beginning-c part: beginning. */
20299 
20300 
20301 /* User-specified code, instruction-beginning-c part: end */
20302 
20303 
20304     /* User code for literal-to-register/nR/%rR . */
20305 
20306     JITTER_ARG1 = JITTER_ARGN0;
20307 
20308     /* End of the user code for literal-to-register/nR/%rR . */
20309 
20310 /* User-specified code, instruction-end-c part: beginning. */
20311 
20312 
20313 /* User-specified code, instruction-end-c part: end */
20314 
20315     /* Undefine the literal-to-register/nR/%rR argument macros so they can't be used
20316        by mistake in the instruction body coming next. */
20317 #   undef JITTER_SLOW_REGISTER_OFFSET0
20318 #   undef JITTER_ARG0
20319 #   undef JITTER_ARGN0
20320 #   undef JITTER_ARGU0
20321 #   undef JITTER_ARGP0
20322 #   undef JITTER_ARGF0
20323 #   undef JITTER_SLOW_REGISTER_OFFSET1
20324 #   undef JITTER_ARG1
20325 #   undef JITTER_ARGN1
20326 #   undef JITTER_ARGU1
20327 #   undef JITTER_ARGP1
20328 #   undef JITTER_ARGF1
20329 
20330 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20331 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20332 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20333 
20334   }
20335  JITTER_INSTRUCTION_EPILOG_(literal-to-register/nR/%rR, literal_mto_mregister__nR___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20336 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20337 
20338   JITTER_INSTRUCTION_PROLOG_(nip, nip, hot)
20339   {
20340     /* This specialized instruction is not a replacement. */
20341 #   undef JITTER_BRANCH_FAST
20342 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20343 #   undef JITTER_BRANCH_FAST_IF_ZERO
20344 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20345 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20346 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20347 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20348 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20349 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20350 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20351 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20352 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20353 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20354 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20355 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20356 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20357 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20358 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20359 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20360 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20361 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20362 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20363 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20364 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20365 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20366 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20367 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20368 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20369 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20370 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20371 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20372 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20373 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20374 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20375 #   undef JITTER_BRANCH_FAST_IF_AND
20376 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20377 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20378 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20379 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20380 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20381 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20382 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20383 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20384 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20385 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20386 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20387 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20388 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20389 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20390 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20391 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20392 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20393 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20394 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20395 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20396 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20397 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20398 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20399 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20400 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20401 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20402 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20403 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20404 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20405 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       99
20406 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip
20407 
20408 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip
20409 
20410   /* The residual arity for this instruction does not depend on fast labels. */
20411   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20412 
20413 
20414 #if defined (JITTER_PROFILE_SAMPLE)
20415   JITTER_PROFILE_SAMPLE_UPDATE
20416      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20417       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20418   /* Force the compiler not move sample-profiling instrumentation
20419      beyond this point; this way the actual user code is timed.
20420      This is still not perfect, as residuals are materialised before
20421      we arrive here, but should be adequate at least for slow VM
20422      instructions. */
20423   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20424 #endif
20425 #if defined (JITTER_PROFILE_COUNT)
20426   /* Notice that, differently from the code above, this
20427      instrumentation code *can* be reordered freely: as long as a
20428      VM instruction is counted, the count increment can be placed
20429      anyehere.  Let GCC move this code and possibly achieve better
20430      throughput by exploiting instruction-level parallelism and
20431      therefore approximate more closely a non-profiled build. */
20432   JITTER_PROFILE_COUNT_UPDATE
20433      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20434       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20435 #endif
20436 
20437 /* User-specified code, instruction-beginning-c part: beginning. */
20438 
20439 
20440 /* User-specified code, instruction-beginning-c part: end */
20441 
20442 
20443     /* User code for nip . */
20444 
20445     JITTER_NIP_MAINSTACK();
20446 
20447     /* End of the user code for nip . */
20448 
20449 /* User-specified code, instruction-end-c part: beginning. */
20450 
20451 
20452 /* User-specified code, instruction-end-c part: end */
20453 
20454     /* Undefine the nip argument macros so they can't be used
20455        by mistake in the instruction body coming next. */
20456 
20457 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20458 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20459 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20460 
20461   }
20462  JITTER_INSTRUCTION_EPILOG_(nip, nip, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20463 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20464 
20465   JITTER_INSTRUCTION_PROLOG_(nip-drop, nip_mdrop, hot)
20466   {
20467     /* This specialized instruction is not a replacement. */
20468 #   undef JITTER_BRANCH_FAST
20469 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20470 #   undef JITTER_BRANCH_FAST_IF_ZERO
20471 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20472 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20473 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20474 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20475 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20476 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20477 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20478 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20479 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20480 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20481 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20482 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20483 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20484 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20485 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20486 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20487 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20488 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20489 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20490 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20491 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20492 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20493 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20494 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20495 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20496 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20497 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20498 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20499 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20500 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20501 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20502 #   undef JITTER_BRANCH_FAST_IF_AND
20503 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20504 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20505 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20506 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20507 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20508 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20509 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20510 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20511 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20512 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20513 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20514 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20515 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20516 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20517 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20518 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20519 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20520 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20521 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20522 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20523 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20524 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20525 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20526 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20527 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20528 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20529 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20530 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20531 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20532 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       100
20533 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-drop
20534 
20535 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mdrop
20536 
20537   /* The residual arity for this instruction does not depend on fast labels. */
20538   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20539 
20540 
20541 #if defined (JITTER_PROFILE_SAMPLE)
20542   JITTER_PROFILE_SAMPLE_UPDATE
20543      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20544       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20545   /* Force the compiler not move sample-profiling instrumentation
20546      beyond this point; this way the actual user code is timed.
20547      This is still not perfect, as residuals are materialised before
20548      we arrive here, but should be adequate at least for slow VM
20549      instructions. */
20550   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20551 #endif
20552 #if defined (JITTER_PROFILE_COUNT)
20553   /* Notice that, differently from the code above, this
20554      instrumentation code *can* be reordered freely: as long as a
20555      VM instruction is counted, the count increment can be placed
20556      anyehere.  Let GCC move this code and possibly achieve better
20557      throughput by exploiting instruction-level parallelism and
20558      therefore approximate more closely a non-profiled build. */
20559   JITTER_PROFILE_COUNT_UPDATE
20560      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20561       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20562 #endif
20563 
20564 /* User-specified code, instruction-beginning-c part: beginning. */
20565 
20566 
20567 /* User-specified code, instruction-beginning-c part: end */
20568 
20569 
20570     /* User code for nip-drop . */
20571 
20572     JITTER_NIP_MAINSTACK();
20573     JITTER_DROP_MAINSTACK();
20574 
20575     /* End of the user code for nip-drop . */
20576 
20577 /* User-specified code, instruction-end-c part: beginning. */
20578 
20579 
20580 /* User-specified code, instruction-end-c part: end */
20581 
20582     /* Undefine the nip-drop argument macros so they can't be used
20583        by mistake in the instruction body coming next. */
20584 
20585 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20586 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20587 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20588 
20589   }
20590  JITTER_INSTRUCTION_EPILOG_(nip-drop, nip_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20591 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20592 
20593   JITTER_INSTRUCTION_PROLOG_(nip-five, nip_mfive, hot)
20594   {
20595     /* This specialized instruction is not a replacement. */
20596 #   undef JITTER_BRANCH_FAST
20597 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20598 #   undef JITTER_BRANCH_FAST_IF_ZERO
20599 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20600 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20601 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20602 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20603 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20604 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20605 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20606 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20607 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20608 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20609 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20610 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20611 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20612 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20613 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20614 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20615 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20616 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20617 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20618 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20619 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20620 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20621 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20622 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20623 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20624 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20625 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20626 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20627 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20628 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20629 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20630 #   undef JITTER_BRANCH_FAST_IF_AND
20631 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20632 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20633 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20634 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20635 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20636 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20637 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20638 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20639 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20640 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20641 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20642 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20643 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20644 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20645 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20646 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20647 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20648 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20649 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20650 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20651 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20652 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20653 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20654 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20655 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20656 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20657 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20658 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20659 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20660 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       101
20661 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-five
20662 
20663 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfive
20664 
20665   /* The residual arity for this instruction does not depend on fast labels. */
20666   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20667 
20668 
20669 #if defined (JITTER_PROFILE_SAMPLE)
20670   JITTER_PROFILE_SAMPLE_UPDATE
20671      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20672       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20673   /* Force the compiler not move sample-profiling instrumentation
20674      beyond this point; this way the actual user code is timed.
20675      This is still not perfect, as residuals are materialised before
20676      we arrive here, but should be adequate at least for slow VM
20677      instructions. */
20678   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20679 #endif
20680 #if defined (JITTER_PROFILE_COUNT)
20681   /* Notice that, differently from the code above, this
20682      instrumentation code *can* be reordered freely: as long as a
20683      VM instruction is counted, the count increment can be placed
20684      anyehere.  Let GCC move this code and possibly achieve better
20685      throughput by exploiting instruction-level parallelism and
20686      therefore approximate more closely a non-profiled build. */
20687   JITTER_PROFILE_COUNT_UPDATE
20688      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20689       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20690 #endif
20691 
20692 /* User-specified code, instruction-beginning-c part: beginning. */
20693 
20694 
20695 /* User-specified code, instruction-beginning-c part: end */
20696 
20697 
20698     /* User code for nip-five . */
20699 
20700     JITTER_NIP_MAINSTACK();
20701     JITTER_NIP_MAINSTACK();
20702     JITTER_NIP_MAINSTACK();
20703     JITTER_NIP_MAINSTACK();
20704     JITTER_NIP_MAINSTACK();
20705 
20706     /* End of the user code for nip-five . */
20707 
20708 /* User-specified code, instruction-end-c part: beginning. */
20709 
20710 
20711 /* User-specified code, instruction-end-c part: end */
20712 
20713     /* Undefine the nip-five argument macros so they can't be used
20714        by mistake in the instruction body coming next. */
20715 
20716 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20717 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20718 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20719 
20720   }
20721  JITTER_INSTRUCTION_EPILOG_(nip-five, nip_mfive, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20722 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20723 
20724   JITTER_INSTRUCTION_PROLOG_(nip-five-drop, nip_mfive_mdrop, hot)
20725   {
20726     /* This specialized instruction is not a replacement. */
20727 #   undef JITTER_BRANCH_FAST
20728 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20729 #   undef JITTER_BRANCH_FAST_IF_ZERO
20730 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20731 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20732 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20733 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20734 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20735 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20736 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20737 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20738 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20739 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20740 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20741 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20742 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20743 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20744 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20745 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20746 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20747 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20748 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20749 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20750 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20751 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20752 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20753 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20754 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20755 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20756 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20757 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20758 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20759 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20760 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20761 #   undef JITTER_BRANCH_FAST_IF_AND
20762 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20763 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20764 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20765 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20766 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20767 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20768 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20769 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20770 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20771 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20772 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20773 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20774 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20775 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20776 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20777 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20778 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20779 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20780 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20781 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20782 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20783 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20784 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20785 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20786 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20787 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20788 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20789 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20790 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20791 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       102
20792 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-five-drop
20793 
20794 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfive_mdrop
20795 
20796   /* The residual arity for this instruction does not depend on fast labels. */
20797   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20798 
20799 
20800 #if defined (JITTER_PROFILE_SAMPLE)
20801   JITTER_PROFILE_SAMPLE_UPDATE
20802      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20803       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20804   /* Force the compiler not move sample-profiling instrumentation
20805      beyond this point; this way the actual user code is timed.
20806      This is still not perfect, as residuals are materialised before
20807      we arrive here, but should be adequate at least for slow VM
20808      instructions. */
20809   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20810 #endif
20811 #if defined (JITTER_PROFILE_COUNT)
20812   /* Notice that, differently from the code above, this
20813      instrumentation code *can* be reordered freely: as long as a
20814      VM instruction is counted, the count increment can be placed
20815      anyehere.  Let GCC move this code and possibly achieve better
20816      throughput by exploiting instruction-level parallelism and
20817      therefore approximate more closely a non-profiled build. */
20818   JITTER_PROFILE_COUNT_UPDATE
20819      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20820       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20821 #endif
20822 
20823 /* User-specified code, instruction-beginning-c part: beginning. */
20824 
20825 
20826 /* User-specified code, instruction-beginning-c part: end */
20827 
20828 
20829     /* User code for nip-five-drop . */
20830 
20831     JITTER_NIP_MAINSTACK();
20832     JITTER_NIP_MAINSTACK();
20833     JITTER_NIP_MAINSTACK();
20834     JITTER_NIP_MAINSTACK();
20835     JITTER_NIP_MAINSTACK();
20836     JITTER_DROP_MAINSTACK();
20837 
20838     /* End of the user code for nip-five-drop . */
20839 
20840 /* User-specified code, instruction-end-c part: beginning. */
20841 
20842 
20843 /* User-specified code, instruction-end-c part: end */
20844 
20845     /* Undefine the nip-five-drop argument macros so they can't be used
20846        by mistake in the instruction body coming next. */
20847 
20848 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20849 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20850 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20851 
20852   }
20853  JITTER_INSTRUCTION_EPILOG_(nip-five-drop, nip_mfive_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20854 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20855 
20856   JITTER_INSTRUCTION_PROLOG_(nip-four, nip_mfour, hot)
20857   {
20858     /* This specialized instruction is not a replacement. */
20859 #   undef JITTER_BRANCH_FAST
20860 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20861 #   undef JITTER_BRANCH_FAST_IF_ZERO
20862 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20863 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20864 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20865 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20866 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20867 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20868 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20869 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
20870 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
20871 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
20872 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
20873 #   undef JITTER_BRANCH_FAST_IF_EQUAL
20874 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
20875 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
20876 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
20877 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
20878 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
20879 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20880 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
20881 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20882 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
20883 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20884 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
20885 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20886 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
20887 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20888 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
20889 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20890 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
20891 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20892 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
20893 #   undef JITTER_BRANCH_FAST_IF_AND
20894 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
20895 #   undef JITTER_BRANCH_FAST_IF_NOTAND
20896 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
20897 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20898 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
20899 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20900 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
20901 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20902 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
20903 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20904 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
20905 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20906 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
20907 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20908 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
20909 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20910 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
20911 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20912 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
20913 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20914 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
20915 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20916 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
20917 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20918 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
20919 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20920 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
20921 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20922 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
20923 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       103
20924 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-four
20925 
20926 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfour
20927 
20928   /* The residual arity for this instruction does not depend on fast labels. */
20929   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
20930 
20931 
20932 #if defined (JITTER_PROFILE_SAMPLE)
20933   JITTER_PROFILE_SAMPLE_UPDATE
20934      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20935       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20936   /* Force the compiler not move sample-profiling instrumentation
20937      beyond this point; this way the actual user code is timed.
20938      This is still not perfect, as residuals are materialised before
20939      we arrive here, but should be adequate at least for slow VM
20940      instructions. */
20941   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
20942 #endif
20943 #if defined (JITTER_PROFILE_COUNT)
20944   /* Notice that, differently from the code above, this
20945      instrumentation code *can* be reordered freely: as long as a
20946      VM instruction is counted, the count increment can be placed
20947      anyehere.  Let GCC move this code and possibly achieve better
20948      throughput by exploiting instruction-level parallelism and
20949      therefore approximate more closely a non-profiled build. */
20950   JITTER_PROFILE_COUNT_UPDATE
20951      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
20952       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
20953 #endif
20954 
20955 /* User-specified code, instruction-beginning-c part: beginning. */
20956 
20957 
20958 /* User-specified code, instruction-beginning-c part: end */
20959 
20960 
20961     /* User code for nip-four . */
20962 
20963     JITTER_NIP_MAINSTACK();
20964     JITTER_NIP_MAINSTACK();
20965     JITTER_NIP_MAINSTACK();
20966     JITTER_NIP_MAINSTACK();
20967 
20968     /* End of the user code for nip-four . */
20969 
20970 /* User-specified code, instruction-end-c part: beginning. */
20971 
20972 
20973 /* User-specified code, instruction-end-c part: end */
20974 
20975     /* Undefine the nip-four argument macros so they can't be used
20976        by mistake in the instruction body coming next. */
20977 
20978 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
20979 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
20980 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
20981 
20982   }
20983  JITTER_INSTRUCTION_EPILOG_(nip-four, nip_mfour, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
20984 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
20985 
20986   JITTER_INSTRUCTION_PROLOG_(nip-four-drop, nip_mfour_mdrop, hot)
20987   {
20988     /* This specialized instruction is not a replacement. */
20989 #   undef JITTER_BRANCH_FAST
20990 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
20991 #   undef JITTER_BRANCH_FAST_IF_ZERO
20992 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
20993 #   undef JITTER_BRANCH_FAST_IF_NONZERO
20994 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
20995 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
20996 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
20997 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
20998 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
20999 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21000 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21001 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21002 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21003 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21004 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21005 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21006 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21007 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21008 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21009 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21010 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21011 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21012 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21013 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21014 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21015 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21016 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21017 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21018 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21019 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21020 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21021 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21022 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21023 #   undef JITTER_BRANCH_FAST_IF_AND
21024 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21025 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21026 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21027 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21028 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21029 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21030 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21031 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21032 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21033 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21034 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21035 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21036 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21037 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21038 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21039 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21040 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21041 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21042 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21043 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21044 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21045 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21046 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21047 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21048 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21049 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21050 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21051 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21052 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21053 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       104
21054 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-four-drop
21055 
21056 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mfour_mdrop
21057 
21058   /* The residual arity for this instruction does not depend on fast labels. */
21059   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21060 
21061 
21062 #if defined (JITTER_PROFILE_SAMPLE)
21063   JITTER_PROFILE_SAMPLE_UPDATE
21064      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21065       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21066   /* Force the compiler not move sample-profiling instrumentation
21067      beyond this point; this way the actual user code is timed.
21068      This is still not perfect, as residuals are materialised before
21069      we arrive here, but should be adequate at least for slow VM
21070      instructions. */
21071   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21072 #endif
21073 #if defined (JITTER_PROFILE_COUNT)
21074   /* Notice that, differently from the code above, this
21075      instrumentation code *can* be reordered freely: as long as a
21076      VM instruction is counted, the count increment can be placed
21077      anyehere.  Let GCC move this code and possibly achieve better
21078      throughput by exploiting instruction-level parallelism and
21079      therefore approximate more closely a non-profiled build. */
21080   JITTER_PROFILE_COUNT_UPDATE
21081      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21082       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21083 #endif
21084 
21085 /* User-specified code, instruction-beginning-c part: beginning. */
21086 
21087 
21088 /* User-specified code, instruction-beginning-c part: end */
21089 
21090 
21091     /* User code for nip-four-drop . */
21092 
21093     JITTER_NIP_MAINSTACK();
21094     JITTER_NIP_MAINSTACK();
21095     JITTER_NIP_MAINSTACK();
21096     JITTER_NIP_MAINSTACK();
21097     JITTER_DROP_MAINSTACK();
21098 
21099     /* End of the user code for nip-four-drop . */
21100 
21101 /* User-specified code, instruction-end-c part: beginning. */
21102 
21103 
21104 /* User-specified code, instruction-end-c part: end */
21105 
21106     /* Undefine the nip-four-drop argument macros so they can't be used
21107        by mistake in the instruction body coming next. */
21108 
21109 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21110 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21111 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21112 
21113   }
21114  JITTER_INSTRUCTION_EPILOG_(nip-four-drop, nip_mfour_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21115 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21116 
21117   JITTER_INSTRUCTION_PROLOG_(nip-push-literal/nR, nip_mpush_mliteral__nR, cold)
21118   {
21119     /* This specialized instruction is not a replacement. */
21120 #   undef JITTER_BRANCH_FAST
21121 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21122 #   undef JITTER_BRANCH_FAST_IF_ZERO
21123 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21124 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21125 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21126 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21127 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21128 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21129 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21130 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21131 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21132 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21133 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21134 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21135 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21136 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21137 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21138 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21139 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21140 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21141 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21142 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21143 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21144 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21145 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21146 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21147 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21148 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21149 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21150 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21151 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21152 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21153 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21154 #   undef JITTER_BRANCH_FAST_IF_AND
21155 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21156 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21157 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21158 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21159 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21160 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21161 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21162 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21163 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21164 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21165 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21166 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21167 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21168 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21169 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21170 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21171 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21172 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21173 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21174 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21175 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21176 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21177 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21178 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21179 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21180 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21181 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21182 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21183 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21184 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       105
21185 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-push-literal/nR
21186 
21187 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mpush_mliteral__nR
21188 
21189   /* The residual arity for this instruction does not depend on fast labels. */
21190   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
21191 
21192     /* The 0th argument is a residual literal. */
21193 #if defined(JITTER_DISPATCH_NO_THREADING)
21194 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
21195     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
21196 #elif defined (JITTER_REPLICATE)
21197 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
21198 #else
21199 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
21200 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
21201 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
21202 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
21203 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
21204 #   define JITTER_ARGF0 JITTER_ARGP0
21205 
21206 
21207 #if defined (JITTER_PROFILE_SAMPLE)
21208   JITTER_PROFILE_SAMPLE_UPDATE
21209      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21210       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21211   /* Force the compiler not move sample-profiling instrumentation
21212      beyond this point; this way the actual user code is timed.
21213      This is still not perfect, as residuals are materialised before
21214      we arrive here, but should be adequate at least for slow VM
21215      instructions. */
21216   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21217 #endif
21218 #if defined (JITTER_PROFILE_COUNT)
21219   /* Notice that, differently from the code above, this
21220      instrumentation code *can* be reordered freely: as long as a
21221      VM instruction is counted, the count increment can be placed
21222      anyehere.  Let GCC move this code and possibly achieve better
21223      throughput by exploiting instruction-level parallelism and
21224      therefore approximate more closely a non-profiled build. */
21225   JITTER_PROFILE_COUNT_UPDATE
21226      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21227       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21228 #endif
21229 
21230 /* User-specified code, instruction-beginning-c part: beginning. */
21231 
21232 
21233 /* User-specified code, instruction-beginning-c part: end */
21234 
21235 
21236     /* User code for nip-push-literal/nR . */
21237 
21238     JITTER_UNDER_TOP_MAINSTACK() = JITTER_TOP_MAINSTACK();
21239     JITTER_TOP_MAINSTACK() = JITTER_ARGN0;
21240 
21241     /* End of the user code for nip-push-literal/nR . */
21242 
21243 /* User-specified code, instruction-end-c part: beginning. */
21244 
21245 
21246 /* User-specified code, instruction-end-c part: end */
21247 
21248     /* Undefine the nip-push-literal/nR argument macros so they can't be used
21249        by mistake in the instruction body coming next. */
21250 #   undef JITTER_SLOW_REGISTER_OFFSET0
21251 #   undef JITTER_ARG0
21252 #   undef JITTER_ARGN0
21253 #   undef JITTER_ARGU0
21254 #   undef JITTER_ARGP0
21255 #   undef JITTER_ARGF0
21256 
21257 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21258 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21259 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21260 
21261   }
21262  JITTER_INSTRUCTION_EPILOG_(nip-push-literal/nR, nip_mpush_mliteral__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21263 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21264 
21265   JITTER_INSTRUCTION_PROLOG_(nip-push-register/%rR, nip_mpush_mregister___rrR, cold)
21266   {
21267     /* This specialized instruction is not a replacement. */
21268 #   undef JITTER_BRANCH_FAST
21269 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21270 #   undef JITTER_BRANCH_FAST_IF_ZERO
21271 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21272 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21273 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21274 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21275 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21276 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21277 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21278 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21279 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21280 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21281 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21282 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21283 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21284 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21285 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21286 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21287 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21288 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21289 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21290 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21291 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21292 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21293 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21294 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21295 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21296 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21297 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21298 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21299 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21300 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21301 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21302 #   undef JITTER_BRANCH_FAST_IF_AND
21303 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21304 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21305 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21306 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21307 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21308 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21309 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21310 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21311 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21312 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21313 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21314 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21315 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21316 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21317 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21318 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21319 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21320 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21321 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21322 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21323 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21324 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21325 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21326 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21327 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21328 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21329 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21330 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21331 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21332 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       106
21333 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-push-register/%rR
21334 
21335 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mpush_mregister___rrR
21336 
21337   /* The residual arity for this instruction does not depend on fast labels. */
21338   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
21339 
21340     /* The 0th argument is a slow (therefore residual, passed as an offset)
21341         register. */
21342   /* Define a macro expanding to the slow register offset. */
21343 #if defined(JITTER_DISPATCH_NO_THREADING)
21344 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
21345 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
21346 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
21347 #else
21348 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
21349 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
21350   /* Define a macro expanding to an l-value for the VM register content. */
21351 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
21352 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
21353 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
21354 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
21355 #   define JITTER_ARGF0 JITTER_ARGP0
21356 
21357 
21358 #if defined (JITTER_PROFILE_SAMPLE)
21359   JITTER_PROFILE_SAMPLE_UPDATE
21360      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21361       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21362   /* Force the compiler not move sample-profiling instrumentation
21363      beyond this point; this way the actual user code is timed.
21364      This is still not perfect, as residuals are materialised before
21365      we arrive here, but should be adequate at least for slow VM
21366      instructions. */
21367   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21368 #endif
21369 #if defined (JITTER_PROFILE_COUNT)
21370   /* Notice that, differently from the code above, this
21371      instrumentation code *can* be reordered freely: as long as a
21372      VM instruction is counted, the count increment can be placed
21373      anyehere.  Let GCC move this code and possibly achieve better
21374      throughput by exploiting instruction-level parallelism and
21375      therefore approximate more closely a non-profiled build. */
21376   JITTER_PROFILE_COUNT_UPDATE
21377      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21378       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21379 #endif
21380 
21381 /* User-specified code, instruction-beginning-c part: beginning. */
21382 
21383 
21384 /* User-specified code, instruction-beginning-c part: end */
21385 
21386 
21387     /* User code for nip-push-register/%rR . */
21388 
21389     JITTER_UNDER_TOP_MAINSTACK() = JITTER_TOP_MAINSTACK();
21390     JITTER_TOP_MAINSTACK() = JITTER_ARG0;
21391 
21392     /* End of the user code for nip-push-register/%rR . */
21393 
21394 /* User-specified code, instruction-end-c part: beginning. */
21395 
21396 
21397 /* User-specified code, instruction-end-c part: end */
21398 
21399     /* Undefine the nip-push-register/%rR argument macros so they can't be used
21400        by mistake in the instruction body coming next. */
21401 #   undef JITTER_SLOW_REGISTER_OFFSET0
21402 #   undef JITTER_ARG0
21403 #   undef JITTER_ARGN0
21404 #   undef JITTER_ARGU0
21405 #   undef JITTER_ARGP0
21406 #   undef JITTER_ARGF0
21407 
21408 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21409 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21410 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21411 
21412   }
21413  JITTER_INSTRUCTION_EPILOG_(nip-push-register/%rR, nip_mpush_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21414 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21415 
21416   JITTER_INSTRUCTION_PROLOG_(nip-six, nip_msix, hot)
21417   {
21418     /* This specialized instruction is not a replacement. */
21419 #   undef JITTER_BRANCH_FAST
21420 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21421 #   undef JITTER_BRANCH_FAST_IF_ZERO
21422 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21423 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21424 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21425 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21426 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21427 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21428 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21429 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21430 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21431 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21432 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21433 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21434 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21435 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21436 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21437 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21438 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21439 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21440 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21441 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21442 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21443 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21444 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21445 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21446 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21447 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21448 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21449 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21450 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21451 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21452 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21453 #   undef JITTER_BRANCH_FAST_IF_AND
21454 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21455 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21456 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21457 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21458 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21459 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21460 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21461 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21462 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21463 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21464 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21465 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21466 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21467 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21468 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21469 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21470 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21471 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21472 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21473 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21474 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21475 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21476 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21477 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21478 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21479 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21480 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21481 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21482 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21483 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       107
21484 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-six
21485 
21486 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_msix
21487 
21488   /* The residual arity for this instruction does not depend on fast labels. */
21489   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21490 
21491 
21492 #if defined (JITTER_PROFILE_SAMPLE)
21493   JITTER_PROFILE_SAMPLE_UPDATE
21494      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21495       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21496   /* Force the compiler not move sample-profiling instrumentation
21497      beyond this point; this way the actual user code is timed.
21498      This is still not perfect, as residuals are materialised before
21499      we arrive here, but should be adequate at least for slow VM
21500      instructions. */
21501   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21502 #endif
21503 #if defined (JITTER_PROFILE_COUNT)
21504   /* Notice that, differently from the code above, this
21505      instrumentation code *can* be reordered freely: as long as a
21506      VM instruction is counted, the count increment can be placed
21507      anyehere.  Let GCC move this code and possibly achieve better
21508      throughput by exploiting instruction-level parallelism and
21509      therefore approximate more closely a non-profiled build. */
21510   JITTER_PROFILE_COUNT_UPDATE
21511      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21512       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21513 #endif
21514 
21515 /* User-specified code, instruction-beginning-c part: beginning. */
21516 
21517 
21518 /* User-specified code, instruction-beginning-c part: end */
21519 
21520 
21521     /* User code for nip-six . */
21522 
21523     JITTER_NIP_MAINSTACK();
21524     JITTER_NIP_MAINSTACK();
21525     JITTER_NIP_MAINSTACK();
21526     JITTER_NIP_MAINSTACK();
21527     JITTER_NIP_MAINSTACK();
21528     JITTER_NIP_MAINSTACK();
21529 
21530     /* End of the user code for nip-six . */
21531 
21532 /* User-specified code, instruction-end-c part: beginning. */
21533 
21534 
21535 /* User-specified code, instruction-end-c part: end */
21536 
21537     /* Undefine the nip-six argument macros so they can't be used
21538        by mistake in the instruction body coming next. */
21539 
21540 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21541 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21542 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21543 
21544   }
21545  JITTER_INSTRUCTION_EPILOG_(nip-six, nip_msix, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21546 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21547 
21548   JITTER_INSTRUCTION_PROLOG_(nip-six-drop, nip_msix_mdrop, hot)
21549   {
21550     /* This specialized instruction is not a replacement. */
21551 #   undef JITTER_BRANCH_FAST
21552 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21553 #   undef JITTER_BRANCH_FAST_IF_ZERO
21554 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21555 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21556 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21557 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21558 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21559 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21560 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21561 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21562 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21563 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21564 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21565 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21566 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21567 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21568 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21569 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21570 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21571 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21572 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21573 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21574 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21575 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21576 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21577 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21578 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21579 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21580 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21581 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21582 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21583 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21584 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21585 #   undef JITTER_BRANCH_FAST_IF_AND
21586 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21587 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21588 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21589 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21590 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21591 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21592 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21593 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21594 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21595 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21596 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21597 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21598 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21599 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21600 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21601 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21602 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21603 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21604 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21605 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21606 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21607 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21608 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21609 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21610 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21611 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21612 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21613 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21614 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21615 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       108
21616 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-six-drop
21617 
21618 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_msix_mdrop
21619 
21620   /* The residual arity for this instruction does not depend on fast labels. */
21621   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21622 
21623 
21624 #if defined (JITTER_PROFILE_SAMPLE)
21625   JITTER_PROFILE_SAMPLE_UPDATE
21626      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21627       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21628   /* Force the compiler not move sample-profiling instrumentation
21629      beyond this point; this way the actual user code is timed.
21630      This is still not perfect, as residuals are materialised before
21631      we arrive here, but should be adequate at least for slow VM
21632      instructions. */
21633   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21634 #endif
21635 #if defined (JITTER_PROFILE_COUNT)
21636   /* Notice that, differently from the code above, this
21637      instrumentation code *can* be reordered freely: as long as a
21638      VM instruction is counted, the count increment can be placed
21639      anyehere.  Let GCC move this code and possibly achieve better
21640      throughput by exploiting instruction-level parallelism and
21641      therefore approximate more closely a non-profiled build. */
21642   JITTER_PROFILE_COUNT_UPDATE
21643      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21644       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21645 #endif
21646 
21647 /* User-specified code, instruction-beginning-c part: beginning. */
21648 
21649 
21650 /* User-specified code, instruction-beginning-c part: end */
21651 
21652 
21653     /* User code for nip-six-drop . */
21654 
21655     JITTER_NIP_MAINSTACK();
21656     JITTER_NIP_MAINSTACK();
21657     JITTER_NIP_MAINSTACK();
21658     JITTER_NIP_MAINSTACK();
21659     JITTER_NIP_MAINSTACK();
21660     JITTER_NIP_MAINSTACK();
21661     JITTER_DROP_MAINSTACK();
21662 
21663     /* End of the user code for nip-six-drop . */
21664 
21665 /* User-specified code, instruction-end-c part: beginning. */
21666 
21667 
21668 /* User-specified code, instruction-end-c part: end */
21669 
21670     /* Undefine the nip-six-drop argument macros so they can't be used
21671        by mistake in the instruction body coming next. */
21672 
21673 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21674 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21675 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21676 
21677   }
21678  JITTER_INSTRUCTION_EPILOG_(nip-six-drop, nip_msix_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21679 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21680 
21681   JITTER_INSTRUCTION_PROLOG_(nip-three, nip_mthree, hot)
21682   {
21683     /* This specialized instruction is not a replacement. */
21684 #   undef JITTER_BRANCH_FAST
21685 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21686 #   undef JITTER_BRANCH_FAST_IF_ZERO
21687 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21688 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21689 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21690 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21691 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21692 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21693 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21694 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21695 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21696 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21697 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21698 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21699 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21700 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21701 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21702 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21703 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21704 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21705 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21706 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21707 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21708 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21709 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21710 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21711 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21712 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21713 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21714 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21715 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21716 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21717 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21718 #   undef JITTER_BRANCH_FAST_IF_AND
21719 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21720 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21721 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21722 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21723 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21724 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21725 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21726 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21727 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21728 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21729 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21730 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21731 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21732 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21733 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21734 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21735 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21736 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21737 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21738 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21739 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21740 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21741 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21742 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21743 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21744 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21745 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21746 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21747 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21748 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       109
21749 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-three
21750 
21751 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mthree
21752 
21753   /* The residual arity for this instruction does not depend on fast labels. */
21754   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21755 
21756 
21757 #if defined (JITTER_PROFILE_SAMPLE)
21758   JITTER_PROFILE_SAMPLE_UPDATE
21759      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21760       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21761   /* Force the compiler not move sample-profiling instrumentation
21762      beyond this point; this way the actual user code is timed.
21763      This is still not perfect, as residuals are materialised before
21764      we arrive here, but should be adequate at least for slow VM
21765      instructions. */
21766   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21767 #endif
21768 #if defined (JITTER_PROFILE_COUNT)
21769   /* Notice that, differently from the code above, this
21770      instrumentation code *can* be reordered freely: as long as a
21771      VM instruction is counted, the count increment can be placed
21772      anyehere.  Let GCC move this code and possibly achieve better
21773      throughput by exploiting instruction-level parallelism and
21774      therefore approximate more closely a non-profiled build. */
21775   JITTER_PROFILE_COUNT_UPDATE
21776      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21777       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21778 #endif
21779 
21780 /* User-specified code, instruction-beginning-c part: beginning. */
21781 
21782 
21783 /* User-specified code, instruction-beginning-c part: end */
21784 
21785 
21786     /* User code for nip-three . */
21787 
21788     JITTER_NIP_MAINSTACK();
21789     JITTER_NIP_MAINSTACK();
21790     JITTER_NIP_MAINSTACK();
21791 
21792     /* End of the user code for nip-three . */
21793 
21794 /* User-specified code, instruction-end-c part: beginning. */
21795 
21796 
21797 /* User-specified code, instruction-end-c part: end */
21798 
21799     /* Undefine the nip-three argument macros so they can't be used
21800        by mistake in the instruction body coming next. */
21801 
21802 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21803 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21804 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21805 
21806   }
21807  JITTER_INSTRUCTION_EPILOG_(nip-three, nip_mthree, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21808 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21809 
21810   JITTER_INSTRUCTION_PROLOG_(nip-three-drop, nip_mthree_mdrop, hot)
21811   {
21812     /* This specialized instruction is not a replacement. */
21813 #   undef JITTER_BRANCH_FAST
21814 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21815 #   undef JITTER_BRANCH_FAST_IF_ZERO
21816 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21817 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21818 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21819 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21820 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21821 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21822 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21823 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21824 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21825 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21826 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21827 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21828 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21829 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21830 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21831 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21832 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21833 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21834 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21835 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21836 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21837 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21838 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21839 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21840 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21841 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21842 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21843 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21844 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21845 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21846 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21847 #   undef JITTER_BRANCH_FAST_IF_AND
21848 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21849 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21850 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21851 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21852 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21853 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21854 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21855 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21856 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21857 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21858 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21859 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21860 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21861 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21862 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21863 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21864 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21865 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21866 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21867 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21868 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21869 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21870 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
21871 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21872 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
21873 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21874 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
21875 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21876 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
21877 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       110
21878 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-three-drop
21879 
21880 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mthree_mdrop
21881 
21882   /* The residual arity for this instruction does not depend on fast labels. */
21883   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
21884 
21885 
21886 #if defined (JITTER_PROFILE_SAMPLE)
21887   JITTER_PROFILE_SAMPLE_UPDATE
21888      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21889       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21890   /* Force the compiler not move sample-profiling instrumentation
21891      beyond this point; this way the actual user code is timed.
21892      This is still not perfect, as residuals are materialised before
21893      we arrive here, but should be adequate at least for slow VM
21894      instructions. */
21895   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
21896 #endif
21897 #if defined (JITTER_PROFILE_COUNT)
21898   /* Notice that, differently from the code above, this
21899      instrumentation code *can* be reordered freely: as long as a
21900      VM instruction is counted, the count increment can be placed
21901      anyehere.  Let GCC move this code and possibly achieve better
21902      throughput by exploiting instruction-level parallelism and
21903      therefore approximate more closely a non-profiled build. */
21904   JITTER_PROFILE_COUNT_UPDATE
21905      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
21906       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
21907 #endif
21908 
21909 /* User-specified code, instruction-beginning-c part: beginning. */
21910 
21911 
21912 /* User-specified code, instruction-beginning-c part: end */
21913 
21914 
21915     /* User code for nip-three-drop . */
21916 
21917     JITTER_NIP_MAINSTACK();
21918     JITTER_NIP_MAINSTACK();
21919     JITTER_NIP_MAINSTACK();
21920     JITTER_DROP_MAINSTACK();
21921 
21922     /* End of the user code for nip-three-drop . */
21923 
21924 /* User-specified code, instruction-end-c part: beginning. */
21925 
21926 
21927 /* User-specified code, instruction-end-c part: end */
21928 
21929     /* Undefine the nip-three-drop argument macros so they can't be used
21930        by mistake in the instruction body coming next. */
21931 
21932 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
21933 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
21934 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
21935 
21936   }
21937  JITTER_INSTRUCTION_EPILOG_(nip-three-drop, nip_mthree_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
21938 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
21939 
21940   JITTER_INSTRUCTION_PROLOG_(nip-two, nip_mtwo, hot)
21941   {
21942     /* This specialized instruction is not a replacement. */
21943 #   undef JITTER_BRANCH_FAST
21944 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
21945 #   undef JITTER_BRANCH_FAST_IF_ZERO
21946 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
21947 #   undef JITTER_BRANCH_FAST_IF_NONZERO
21948 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
21949 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
21950 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
21951 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
21952 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
21953 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
21954 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
21955 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
21956 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
21957 #   undef JITTER_BRANCH_FAST_IF_EQUAL
21958 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
21959 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
21960 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
21961 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
21962 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
21963 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21964 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
21965 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21966 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
21967 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21968 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
21969 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21970 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
21971 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21972 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
21973 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21974 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
21975 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21976 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
21977 #   undef JITTER_BRANCH_FAST_IF_AND
21978 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
21979 #   undef JITTER_BRANCH_FAST_IF_NOTAND
21980 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
21981 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21982 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
21983 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21984 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
21985 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21986 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
21987 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21988 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
21989 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21990 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
21991 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21992 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
21993 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21994 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
21995 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21996 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
21997 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21998 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
21999 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22000 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22001 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22002 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22003 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22004 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22005 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22006 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22007 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       111
22008 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-two
22009 
22010 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mtwo
22011 
22012   /* The residual arity for this instruction does not depend on fast labels. */
22013   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22014 
22015 
22016 #if defined (JITTER_PROFILE_SAMPLE)
22017   JITTER_PROFILE_SAMPLE_UPDATE
22018      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22019       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22020   /* Force the compiler not move sample-profiling instrumentation
22021      beyond this point; this way the actual user code is timed.
22022      This is still not perfect, as residuals are materialised before
22023      we arrive here, but should be adequate at least for slow VM
22024      instructions. */
22025   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22026 #endif
22027 #if defined (JITTER_PROFILE_COUNT)
22028   /* Notice that, differently from the code above, this
22029      instrumentation code *can* be reordered freely: as long as a
22030      VM instruction is counted, the count increment can be placed
22031      anyehere.  Let GCC move this code and possibly achieve better
22032      throughput by exploiting instruction-level parallelism and
22033      therefore approximate more closely a non-profiled build. */
22034   JITTER_PROFILE_COUNT_UPDATE
22035      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22036       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22037 #endif
22038 
22039 /* User-specified code, instruction-beginning-c part: beginning. */
22040 
22041 
22042 /* User-specified code, instruction-beginning-c part: end */
22043 
22044 
22045     /* User code for nip-two . */
22046 
22047     JITTER_NIP_MAINSTACK();
22048     JITTER_NIP_MAINSTACK();
22049 
22050     /* End of the user code for nip-two . */
22051 
22052 /* User-specified code, instruction-end-c part: beginning. */
22053 
22054 
22055 /* User-specified code, instruction-end-c part: end */
22056 
22057     /* Undefine the nip-two argument macros so they can't be used
22058        by mistake in the instruction body coming next. */
22059 
22060 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22061 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22062 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22063 
22064   }
22065  JITTER_INSTRUCTION_EPILOG_(nip-two, nip_mtwo, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22066 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22067 
22068   JITTER_INSTRUCTION_PROLOG_(nip-two-drop, nip_mtwo_mdrop, hot)
22069   {
22070     /* This specialized instruction is not a replacement. */
22071 #   undef JITTER_BRANCH_FAST
22072 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22073 #   undef JITTER_BRANCH_FAST_IF_ZERO
22074 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22075 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22076 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22077 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22078 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22079 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22080 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22081 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22082 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22083 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22084 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22085 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22086 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22087 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22088 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22089 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22090 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22091 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22092 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22093 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22094 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22095 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22096 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22097 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22098 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22099 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22100 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22101 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22102 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22103 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22104 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22105 #   undef JITTER_BRANCH_FAST_IF_AND
22106 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22107 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22108 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22109 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22110 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22111 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22112 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22113 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22114 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22115 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22116 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22117 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22118 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22119 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22120 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22121 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22122 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22123 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22124 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22125 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22126 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22127 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22128 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22129 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22130 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22131 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22132 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22133 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22134 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22135 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       112
22136 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nip-two-drop
22137 
22138 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nip_mtwo_mdrop
22139 
22140   /* The residual arity for this instruction does not depend on fast labels. */
22141   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22142 
22143 
22144 #if defined (JITTER_PROFILE_SAMPLE)
22145   JITTER_PROFILE_SAMPLE_UPDATE
22146      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22147       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22148   /* Force the compiler not move sample-profiling instrumentation
22149      beyond this point; this way the actual user code is timed.
22150      This is still not perfect, as residuals are materialised before
22151      we arrive here, but should be adequate at least for slow VM
22152      instructions. */
22153   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22154 #endif
22155 #if defined (JITTER_PROFILE_COUNT)
22156   /* Notice that, differently from the code above, this
22157      instrumentation code *can* be reordered freely: as long as a
22158      VM instruction is counted, the count increment can be placed
22159      anyehere.  Let GCC move this code and possibly achieve better
22160      throughput by exploiting instruction-level parallelism and
22161      therefore approximate more closely a non-profiled build. */
22162   JITTER_PROFILE_COUNT_UPDATE
22163      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22164       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22165 #endif
22166 
22167 /* User-specified code, instruction-beginning-c part: beginning. */
22168 
22169 
22170 /* User-specified code, instruction-beginning-c part: end */
22171 
22172 
22173     /* User code for nip-two-drop . */
22174 
22175     JITTER_NIP_MAINSTACK();
22176     JITTER_NIP_MAINSTACK();
22177     JITTER_DROP_MAINSTACK();
22178 
22179     /* End of the user code for nip-two-drop . */
22180 
22181 /* User-specified code, instruction-end-c part: beginning. */
22182 
22183 
22184 /* User-specified code, instruction-end-c part: end */
22185 
22186     /* Undefine the nip-two-drop argument macros so they can't be used
22187        by mistake in the instruction body coming next. */
22188 
22189 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22190 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22191 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22192 
22193   }
22194  JITTER_INSTRUCTION_EPILOG_(nip-two-drop, nip_mtwo_mdrop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22195 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22196 
22197   JITTER_INSTRUCTION_PROLOG_(nop, nop, hot)
22198   {
22199     /* This specialized instruction is not a replacement. */
22200 #   undef JITTER_BRANCH_FAST
22201 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22202 #   undef JITTER_BRANCH_FAST_IF_ZERO
22203 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22204 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22205 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22206 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22207 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22208 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22209 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22210 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22211 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22212 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22213 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22214 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22215 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22216 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22217 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22218 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22219 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22220 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22221 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22222 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22223 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22224 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22225 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22226 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22227 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22228 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22229 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22230 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22231 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22232 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22233 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22234 #   undef JITTER_BRANCH_FAST_IF_AND
22235 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22236 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22237 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22238 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22239 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22240 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22241 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22242 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22243 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22244 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22245 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22246 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22247 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22248 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22249 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22250 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22251 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22252 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22253 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22254 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22255 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22256 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22257 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22258 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22259 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22260 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22261 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22262 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22263 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22264 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       113
22265 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         nop
22266 
22267 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME nop
22268 
22269   /* The residual arity for this instruction does not depend on fast labels. */
22270   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
22271 
22272 
22273 #if defined (JITTER_PROFILE_SAMPLE)
22274   JITTER_PROFILE_SAMPLE_UPDATE
22275      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22276       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22277   /* Force the compiler not move sample-profiling instrumentation
22278      beyond this point; this way the actual user code is timed.
22279      This is still not perfect, as residuals are materialised before
22280      we arrive here, but should be adequate at least for slow VM
22281      instructions. */
22282   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22283 #endif
22284 #if defined (JITTER_PROFILE_COUNT)
22285   /* Notice that, differently from the code above, this
22286      instrumentation code *can* be reordered freely: as long as a
22287      VM instruction is counted, the count increment can be placed
22288      anyehere.  Let GCC move this code and possibly achieve better
22289      throughput by exploiting instruction-level parallelism and
22290      therefore approximate more closely a non-profiled build. */
22291   JITTER_PROFILE_COUNT_UPDATE
22292      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22293       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22294 #endif
22295 
22296 /* User-specified code, instruction-beginning-c part: beginning. */
22297 
22298 
22299 /* User-specified code, instruction-beginning-c part: end */
22300 
22301 
22302     /* User code for nop . */
22303 
22304 
22305     /* End of the user code for nop . */
22306 
22307 /* User-specified code, instruction-end-c part: beginning. */
22308 
22309 
22310 /* User-specified code, instruction-end-c part: end */
22311 
22312     /* Undefine the nop argument macros so they can't be used
22313        by mistake in the instruction body coming next. */
22314 
22315 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22316 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22317 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22318 
22319   }
22320  JITTER_INSTRUCTION_EPILOG_(nop, nop, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22321 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22322 
22323   JITTER_INSTRUCTION_PROLOG_(pop-to-global/nR/fR, pop_mto_mglobal__nR__fR, cold)
22324   {
22325     /* This specialized instruction is not a replacement. */
22326 #   undef JITTER_BRANCH_FAST
22327 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22328 #   undef JITTER_BRANCH_FAST_IF_ZERO
22329 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22330 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22331 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22332 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22333 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22334 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22335 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22336 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22337 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22338 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22339 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22340 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22341 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22342 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22343 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22344 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22345 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22346 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22347 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22348 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22349 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22350 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22351 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22352 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22353 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22354 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22355 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22356 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22357 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22358 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22359 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22360 #   undef JITTER_BRANCH_FAST_IF_AND
22361 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22362 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22363 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22364 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22365 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22366 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22367 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22368 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22369 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22370 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22371 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22372 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22373 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22374 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22375 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22376 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22377 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22378 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22379 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22380 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22381 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22382 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22383 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22384 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22385 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22386 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22387 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22388 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22389 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22390 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       114
22391 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pop-to-global/nR/fR
22392 
22393 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pop_mto_mglobal__nR__fR
22394 
22395   /* The residual arity varies depending on whether we have fast labels. */
22396 #ifdef JITTER_HAVE_PATCH_IN
22397   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
22398 #else
22399   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
22400 #endif // #ifdef JITTER_HAVE_PATCH_IN
22401 
22402   /* Define argument-access macros for pop-to-global/nR/fR . */
22403 #ifdef JITTER_HAVE_PATCH_IN
22404   /* Define argument-access macros assuming that fast branches are enabled. */
22405     /* The 0th argument is a residual literal. */
22406 #if defined(JITTER_DISPATCH_NO_THREADING)
22407 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
22408     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
22409 #elif defined (JITTER_REPLICATE)
22410 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
22411 #else
22412 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
22413 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22414 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
22415 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
22416 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
22417 
22418     /* The 1th argument is a "residual" fast label.  Define its
22419        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
22420        so that at replication time we know what instruction address to patch in. */
22421 #   define JITTER_ARGF1 0
22422     /* JITTER_ARG1 is intentionally not defined for a fast label. */
22423 
22424 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
22425 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
22426 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
22427 
22428 #else
22429   /* Define argument-access macros assuming that fast branches are disabled. */
22430     /* The 0th argument is a residual literal. */
22431 #if defined(JITTER_DISPATCH_NO_THREADING)
22432 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
22433     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
22434 #elif defined (JITTER_REPLICATE)
22435 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
22436 #else
22437 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
22438 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22439 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
22440 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
22441 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
22442 #   define JITTER_ARGF0 JITTER_ARGP0
22443 
22444 #if defined(JITTER_DISPATCH_NO_THREADING)
22445 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
22446     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
22447 #elif defined (JITTER_REPLICATE)
22448 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
22449 #else
22450 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
22451 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22452 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
22453 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
22454 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
22455 #   define JITTER_ARGF1 JITTER_ARGP1
22456 
22457 # endif // #ifdef JITTER_HAVE_PATCH_IN
22458 
22459 #if defined (JITTER_PROFILE_SAMPLE)
22460   JITTER_PROFILE_SAMPLE_UPDATE
22461      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22462       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22463   /* Force the compiler not move sample-profiling instrumentation
22464      beyond this point; this way the actual user code is timed.
22465      This is still not perfect, as residuals are materialised before
22466      we arrive here, but should be adequate at least for slow VM
22467      instructions. */
22468   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22469 #endif
22470 #if defined (JITTER_PROFILE_COUNT)
22471   /* Notice that, differently from the code above, this
22472      instrumentation code *can* be reordered freely: as long as a
22473      VM instruction is counted, the count increment can be placed
22474      anyehere.  Let GCC move this code and possibly achieve better
22475      throughput by exploiting instruction-level parallelism and
22476      therefore approximate more closely a non-profiled build. */
22477   JITTER_PROFILE_COUNT_UPDATE
22478      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22479       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22480 #endif
22481 
22482 /* User-specified code, instruction-beginning-c part: beginning. */
22483 
22484 
22485 /* User-specified code, instruction-beginning-c part: end */
22486 
22487 
22488     /* User code for pop-to-global/nR/fR . */
22489 
22490     jitterlisp_object tagged_symbol = JITTER_ARGN0;
22491     struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
22492 #ifndef JITTERLISP_UNSAFE
22493     JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
22494 #endif // #ifndef JITTERLISP_UNSAFE
22495     symbol->global_value = JITTER_TOP_MAINSTACK();
22496     JITTER_DROP_MAINSTACK();
22497 
22498     /* End of the user code for pop-to-global/nR/fR . */
22499 
22500 /* User-specified code, instruction-end-c part: beginning. */
22501 
22502 
22503 /* User-specified code, instruction-end-c part: end */
22504 
22505     /* Undefine the pop-to-global/nR/fR argument macros so they can't be used
22506        by mistake in the instruction body coming next. */
22507 #   undef JITTER_SLOW_REGISTER_OFFSET0
22508 #   undef JITTER_ARG0
22509 #   undef JITTER_ARGN0
22510 #   undef JITTER_ARGU0
22511 #   undef JITTER_ARGP0
22512 #   undef JITTER_ARGF0
22513 #   undef JITTER_SLOW_REGISTER_OFFSET1
22514 #   undef JITTER_ARG1
22515 #   undef JITTER_ARGN1
22516 #   undef JITTER_ARGU1
22517 #   undef JITTER_ARGP1
22518 #   undef JITTER_ARGF1
22519 
22520 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22521 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22522 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22523 
22524   }
22525  JITTER_INSTRUCTION_EPILOG_(pop-to-global/nR/fR, pop_mto_mglobal__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22526 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22527 
22528   JITTER_INSTRUCTION_PROLOG_(pop-to-global-defined/nR/fR, pop_mto_mglobal_mdefined__nR__fR, cold)
22529   {
22530     /* This specialized instruction is not a replacement. */
22531 #   undef JITTER_BRANCH_FAST
22532 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22533 #   undef JITTER_BRANCH_FAST_IF_ZERO
22534 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22535 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22536 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22537 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22538 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22539 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22540 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22541 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22542 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22543 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22544 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22545 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22546 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22547 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22548 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22549 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22550 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22551 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22552 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22553 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22554 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22555 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22556 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22557 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22558 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22559 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22560 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22561 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22562 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22563 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22564 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22565 #   undef JITTER_BRANCH_FAST_IF_AND
22566 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22567 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22568 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22569 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22570 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22571 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22572 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22573 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22574 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22575 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22576 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22577 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22578 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22579 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22580 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22581 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22582 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22583 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22584 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22585 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22586 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22587 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22588 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22589 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22590 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22591 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22592 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22593 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22594 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22595 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       115
22596 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pop-to-global-defined/nR/fR
22597 
22598 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pop_mto_mglobal_mdefined__nR__fR
22599 
22600   /* The residual arity varies depending on whether we have fast labels. */
22601 #ifdef JITTER_HAVE_PATCH_IN
22602   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
22603 #else
22604   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
22605 #endif // #ifdef JITTER_HAVE_PATCH_IN
22606 
22607   /* Define argument-access macros for pop-to-global-defined/nR/fR . */
22608 #ifdef JITTER_HAVE_PATCH_IN
22609   /* Define argument-access macros assuming that fast branches are enabled. */
22610     /* The 0th argument is a residual literal. */
22611 #if defined(JITTER_DISPATCH_NO_THREADING)
22612 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
22613     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
22614 #elif defined (JITTER_REPLICATE)
22615 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
22616 #else
22617 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
22618 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22619 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
22620 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
22621 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
22622 
22623     /* The 1th argument is a "residual" fast label.  Define its
22624        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
22625        so that at replication time we know what instruction address to patch in. */
22626 #   define JITTER_ARGF1 0
22627     /* JITTER_ARG1 is intentionally not defined for a fast label. */
22628 
22629 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
22630 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
22631 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
22632 
22633 #else
22634   /* Define argument-access macros assuming that fast branches are disabled. */
22635     /* The 0th argument is a residual literal. */
22636 #if defined(JITTER_DISPATCH_NO_THREADING)
22637 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
22638     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
22639 #elif defined (JITTER_REPLICATE)
22640 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
22641 #else
22642 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
22643 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22644 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
22645 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
22646 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
22647 #   define JITTER_ARGF0 JITTER_ARGP0
22648 
22649 #if defined(JITTER_DISPATCH_NO_THREADING)
22650 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
22651     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
22652 #elif defined (JITTER_REPLICATE)
22653 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
22654 #else
22655 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
22656 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22657 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
22658 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
22659 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
22660 #   define JITTER_ARGF1 JITTER_ARGP1
22661 
22662 # endif // #ifdef JITTER_HAVE_PATCH_IN
22663 
22664 #if defined (JITTER_PROFILE_SAMPLE)
22665   JITTER_PROFILE_SAMPLE_UPDATE
22666      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22667       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22668   /* Force the compiler not move sample-profiling instrumentation
22669      beyond this point; this way the actual user code is timed.
22670      This is still not perfect, as residuals are materialised before
22671      we arrive here, but should be adequate at least for slow VM
22672      instructions. */
22673   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22674 #endif
22675 #if defined (JITTER_PROFILE_COUNT)
22676   /* Notice that, differently from the code above, this
22677      instrumentation code *can* be reordered freely: as long as a
22678      VM instruction is counted, the count increment can be placed
22679      anyehere.  Let GCC move this code and possibly achieve better
22680      throughput by exploiting instruction-level parallelism and
22681      therefore approximate more closely a non-profiled build. */
22682   JITTER_PROFILE_COUNT_UPDATE
22683      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22684       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22685 #endif
22686 
22687 /* User-specified code, instruction-beginning-c part: beginning. */
22688 
22689 
22690 /* User-specified code, instruction-beginning-c part: end */
22691 
22692 
22693     /* User code for pop-to-global-defined/nR/fR . */
22694 
22695     jitterlisp_object tagged_symbol = JITTER_ARGN0;
22696     struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
22697 #ifndef JITTERLISP_UNSAFE
22698     JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
22699     JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
22700                                  JITTER_ARGF1);
22701 #endif // #ifndef JITTERLISP_UNSAFE
22702     symbol->global_value = JITTER_TOP_MAINSTACK();
22703     JITTER_DROP_MAINSTACK();
22704 
22705     /* End of the user code for pop-to-global-defined/nR/fR . */
22706 
22707 /* User-specified code, instruction-end-c part: beginning. */
22708 
22709 
22710 /* User-specified code, instruction-end-c part: end */
22711 
22712     /* Undefine the pop-to-global-defined/nR/fR argument macros so they can't be used
22713        by mistake in the instruction body coming next. */
22714 #   undef JITTER_SLOW_REGISTER_OFFSET0
22715 #   undef JITTER_ARG0
22716 #   undef JITTER_ARGN0
22717 #   undef JITTER_ARGU0
22718 #   undef JITTER_ARGP0
22719 #   undef JITTER_ARGF0
22720 #   undef JITTER_SLOW_REGISTER_OFFSET1
22721 #   undef JITTER_ARG1
22722 #   undef JITTER_ARGN1
22723 #   undef JITTER_ARGU1
22724 #   undef JITTER_ARGP1
22725 #   undef JITTER_ARGF1
22726 
22727 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22728 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22729 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22730 
22731   }
22732  JITTER_INSTRUCTION_EPILOG_(pop-to-global-defined/nR/fR, pop_mto_mglobal_mdefined__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22733 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22734 
22735   JITTER_INSTRUCTION_PROLOG_(pop-to-register/%rR, pop_mto_mregister___rrR, cold)
22736   {
22737     /* This specialized instruction is not a replacement. */
22738 #   undef JITTER_BRANCH_FAST
22739 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22740 #   undef JITTER_BRANCH_FAST_IF_ZERO
22741 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22742 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22743 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22744 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22745 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22746 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22747 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22748 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22749 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22750 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22751 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22752 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22753 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22754 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22755 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22756 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22757 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22758 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22759 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22760 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22761 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22762 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22763 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22764 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22765 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22766 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22767 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22768 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22769 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22770 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22771 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22772 #   undef JITTER_BRANCH_FAST_IF_AND
22773 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22774 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22775 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22776 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22777 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22778 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22779 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22780 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22781 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22782 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22783 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22784 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22785 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22786 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22787 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22788 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22789 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22790 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22791 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22792 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22793 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22794 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22795 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22796 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22797 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22798 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22799 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22800 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22801 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22802 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       116
22803 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         pop-to-register/%rR
22804 
22805 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME pop_mto_mregister___rrR
22806 
22807   /* The residual arity for this instruction does not depend on fast labels. */
22808   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
22809 
22810     /* The 0th argument is a slow (therefore residual, passed as an offset)
22811         register. */
22812   /* Define a macro expanding to the slow register offset. */
22813 #if defined(JITTER_DISPATCH_NO_THREADING)
22814 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
22815 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
22816 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
22817 #else
22818 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
22819 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22820   /* Define a macro expanding to an l-value for the VM register content. */
22821 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
22822 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
22823 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
22824 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
22825 #   define JITTER_ARGF0 JITTER_ARGP0
22826 
22827 
22828 #if defined (JITTER_PROFILE_SAMPLE)
22829   JITTER_PROFILE_SAMPLE_UPDATE
22830      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22831       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22832   /* Force the compiler not move sample-profiling instrumentation
22833      beyond this point; this way the actual user code is timed.
22834      This is still not perfect, as residuals are materialised before
22835      we arrive here, but should be adequate at least for slow VM
22836      instructions. */
22837   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
22838 #endif
22839 #if defined (JITTER_PROFILE_COUNT)
22840   /* Notice that, differently from the code above, this
22841      instrumentation code *can* be reordered freely: as long as a
22842      VM instruction is counted, the count increment can be placed
22843      anyehere.  Let GCC move this code and possibly achieve better
22844      throughput by exploiting instruction-level parallelism and
22845      therefore approximate more closely a non-profiled build. */
22846   JITTER_PROFILE_COUNT_UPDATE
22847      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
22848       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
22849 #endif
22850 
22851 /* User-specified code, instruction-beginning-c part: beginning. */
22852 
22853 
22854 /* User-specified code, instruction-beginning-c part: end */
22855 
22856 
22857     /* User code for pop-to-register/%rR . */
22858 
22859     JITTER_ARG0 = JITTER_TOP_MAINSTACK();
22860     JITTER_DROP_MAINSTACK();
22861 
22862     /* End of the user code for pop-to-register/%rR . */
22863 
22864 /* User-specified code, instruction-end-c part: beginning. */
22865 
22866 
22867 /* User-specified code, instruction-end-c part: end */
22868 
22869     /* Undefine the pop-to-register/%rR argument macros so they can't be used
22870        by mistake in the instruction body coming next. */
22871 #   undef JITTER_SLOW_REGISTER_OFFSET0
22872 #   undef JITTER_ARG0
22873 #   undef JITTER_ARGN0
22874 #   undef JITTER_ARGU0
22875 #   undef JITTER_ARGP0
22876 #   undef JITTER_ARGF0
22877 
22878 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
22879 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
22880 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
22881 
22882   }
22883  JITTER_INSTRUCTION_EPILOG_(pop-to-register/%rR, pop_mto_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
22884 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
22885 
22886   JITTER_INSTRUCTION_PROLOG_(primitive/nR/n0/fR, primitive__nR__n0__fR, cold)
22887   {
22888     /* This specialized instruction is not a replacement. */
22889 #   undef JITTER_BRANCH_FAST
22890 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
22891 #   undef JITTER_BRANCH_FAST_IF_ZERO
22892 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
22893 #   undef JITTER_BRANCH_FAST_IF_NONZERO
22894 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
22895 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
22896 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
22897 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
22898 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
22899 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
22900 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
22901 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
22902 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
22903 #   undef JITTER_BRANCH_FAST_IF_EQUAL
22904 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
22905 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
22906 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
22907 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
22908 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
22909 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22910 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
22911 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22912 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
22913 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22914 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
22915 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22916 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
22917 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22918 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
22919 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22920 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
22921 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22922 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
22923 #   undef JITTER_BRANCH_FAST_IF_AND
22924 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
22925 #   undef JITTER_BRANCH_FAST_IF_NOTAND
22926 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
22927 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22928 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
22929 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22930 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
22931 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22932 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
22933 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22934 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
22935 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22936 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
22937 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22938 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
22939 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22940 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
22941 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22942 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
22943 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22944 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
22945 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22946 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
22947 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22948 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
22949 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22950 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
22951 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22952 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
22953 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       117
22954 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n0/fR
22955 
22956 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n0__fR
22957 
22958   /* The residual arity varies depending on whether we have fast labels. */
22959 #ifdef JITTER_HAVE_PATCH_IN
22960   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
22961 #else
22962   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
22963 #endif // #ifdef JITTER_HAVE_PATCH_IN
22964 
22965   /* Define argument-access macros for primitive/nR/n0/fR . */
22966 #ifdef JITTER_HAVE_PATCH_IN
22967   /* Define argument-access macros assuming that fast branches are enabled. */
22968     /* The 0th argument is a residual literal. */
22969 #if defined(JITTER_DISPATCH_NO_THREADING)
22970 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
22971     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
22972 #elif defined (JITTER_REPLICATE)
22973 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
22974 #else
22975 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
22976 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
22977 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
22978 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
22979 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
22980 
22981     /* The 1th argument is a nonresidual literal. */
22982 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
22983 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
22984 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
22985 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
22986 
22987     /* The 2th argument is a "residual" fast label.  Define its
22988        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
22989        so that at replication time we know what instruction address to patch in. */
22990 #   define JITTER_ARGF2 0
22991     /* JITTER_ARG2 is intentionally not defined for a fast label. */
22992 
22993 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
22994 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
22995 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
22996 
22997 #else
22998   /* Define argument-access macros assuming that fast branches are disabled. */
22999     /* The 0th argument is a residual literal. */
23000 #if defined(JITTER_DISPATCH_NO_THREADING)
23001 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23002     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23003 #elif defined (JITTER_REPLICATE)
23004 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23005 #else
23006 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23007 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23008 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23009 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23010 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23011 #   define JITTER_ARGF0 JITTER_ARGP0
23012 
23013     /* The 1th argument is a nonresidual literal. */
23014 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
23015 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23016 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23017 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23018 #   define JITTER_ARGF1 JITTER_ARGP1
23019 
23020 #if defined(JITTER_DISPATCH_NO_THREADING)
23021 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
23022     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
23023 #elif defined (JITTER_REPLICATE)
23024 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
23025 #else
23026 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
23027 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23028 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
23029 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
23030 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
23031 #   define JITTER_ARGF2 JITTER_ARGP2
23032 
23033 # endif // #ifdef JITTER_HAVE_PATCH_IN
23034 
23035 #if defined (JITTER_PROFILE_SAMPLE)
23036   JITTER_PROFILE_SAMPLE_UPDATE
23037      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23038       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23039   /* Force the compiler not move sample-profiling instrumentation
23040      beyond this point; this way the actual user code is timed.
23041      This is still not perfect, as residuals are materialised before
23042      we arrive here, but should be adequate at least for slow VM
23043      instructions. */
23044   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23045 #endif
23046 #if defined (JITTER_PROFILE_COUNT)
23047   /* Notice that, differently from the code above, this
23048      instrumentation code *can* be reordered freely: as long as a
23049      VM instruction is counted, the count increment can be placed
23050      anyehere.  Let GCC move this code and possibly achieve better
23051      throughput by exploiting instruction-level parallelism and
23052      therefore approximate more closely a non-profiled build. */
23053   JITTER_PROFILE_COUNT_UPDATE
23054      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23055       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23056 #endif
23057 
23058 /* User-specified code, instruction-beginning-c part: beginning. */
23059 
23060 
23061 /* User-specified code, instruction-beginning-c part: end */
23062 
23063 
23064     /* User code for primitive/nR/n0/fR . */
23065 
23066     /* The error-handling label is not actually used in this case: the
23067        primitive function, written in C, has its own handling.  It's
23068        harmless to have it anyway, as it makes the C code generator
23069        more uniform. */
23070     jitterlisp_primitive_function p
23071       = (jitterlisp_primitive_function) JITTER_ARGP0;
23072     const jitter_uint in_arity = JITTER_ARGN1;
23073     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
23074     //asm volatile ("nop");
23075     jitterlisp_object *first_arg
23076       // FIXME: add a stack operator to compute this address.
23077       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
23078     /* This workaround is needed for Alpha.  I have macros to make this nicer in
23079        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
23080        Jitter. */
23081 /*
23082     void *saved_gp;
23083     asm volatile ("stq $gp, %[saved_gp]"
23084                   : [saved_gp] "=o" (saved_gp),
23085                     "+X" (p));
23086 */
23087     jitterlisp_object res = p (first_arg);
23088     /* Second part of the Alpha workaround. */
23089 /*
23090     asm volatile ("ldq $gp, %[saved_gp]"
23091                   : "+X" (res)
23092                   : [saved_gp] "o" (saved_gp));
23093 */
23094 
23095     jitter_uint i;
23096     // Remove as many elements as the primitive in-arity, but not more:
23097     // the top unspecified value we pushed will be replaced with the result.
23098     for (i = 0; i < in_arity; i ++)
23099       JITTER_NIP_MAINSTACK();
23100     //asm ("unop" : "+g" (jitter_state_runtime));
23101     JITTER_TOP_MAINSTACK() = res;
23102 
23103     /* End of the user code for primitive/nR/n0/fR . */
23104 
23105 /* User-specified code, instruction-end-c part: beginning. */
23106 
23107 
23108 /* User-specified code, instruction-end-c part: end */
23109 
23110     /* Undefine the primitive/nR/n0/fR argument macros so they can't be used
23111        by mistake in the instruction body coming next. */
23112 #   undef JITTER_SLOW_REGISTER_OFFSET0
23113 #   undef JITTER_ARG0
23114 #   undef JITTER_ARGN0
23115 #   undef JITTER_ARGU0
23116 #   undef JITTER_ARGP0
23117 #   undef JITTER_ARGF0
23118 #   undef JITTER_SLOW_REGISTER_OFFSET1
23119 #   undef JITTER_ARG1
23120 #   undef JITTER_ARGN1
23121 #   undef JITTER_ARGU1
23122 #   undef JITTER_ARGP1
23123 #   undef JITTER_ARGF1
23124 #   undef JITTER_SLOW_REGISTER_OFFSET2
23125 #   undef JITTER_ARG2
23126 #   undef JITTER_ARGN2
23127 #   undef JITTER_ARGU2
23128 #   undef JITTER_ARGP2
23129 #   undef JITTER_ARGF2
23130 
23131 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23132 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23133 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23134 
23135   }
23136  JITTER_INSTRUCTION_EPILOG_(primitive/nR/n0/fR, primitive__nR__n0__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23137 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23138 
23139   JITTER_INSTRUCTION_PROLOG_(primitive/nR/n1/fR, primitive__nR__n1__fR, cold)
23140   {
23141     /* This specialized instruction is not a replacement. */
23142 #   undef JITTER_BRANCH_FAST
23143 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23144 #   undef JITTER_BRANCH_FAST_IF_ZERO
23145 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23146 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23147 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23148 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23149 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23150 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23151 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23152 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23153 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23154 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23155 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23156 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23157 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23158 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23159 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23160 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23161 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23162 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23163 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23164 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23165 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23166 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23167 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23168 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23169 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23170 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23171 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23172 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23173 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23174 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23175 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23176 #   undef JITTER_BRANCH_FAST_IF_AND
23177 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23178 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23179 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23180 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23181 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23182 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23183 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23184 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23185 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23186 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23187 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23188 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23189 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23190 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23191 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23192 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23193 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23194 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23195 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23196 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23197 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23198 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23199 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23200 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23201 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23202 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23203 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23204 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23205 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23206 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       118
23207 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n1/fR
23208 
23209 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n1__fR
23210 
23211   /* The residual arity varies depending on whether we have fast labels. */
23212 #ifdef JITTER_HAVE_PATCH_IN
23213   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
23214 #else
23215   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
23216 #endif // #ifdef JITTER_HAVE_PATCH_IN
23217 
23218   /* Define argument-access macros for primitive/nR/n1/fR . */
23219 #ifdef JITTER_HAVE_PATCH_IN
23220   /* Define argument-access macros assuming that fast branches are enabled. */
23221     /* The 0th argument is a residual literal. */
23222 #if defined(JITTER_DISPATCH_NO_THREADING)
23223 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23224     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23225 #elif defined (JITTER_REPLICATE)
23226 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23227 #else
23228 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23229 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23230 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23231 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23232 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23233 
23234     /* The 1th argument is a nonresidual literal. */
23235 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
23236 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23237 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23238 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23239 
23240     /* The 2th argument is a "residual" fast label.  Define its
23241        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
23242        so that at replication time we know what instruction address to patch in. */
23243 #   define JITTER_ARGF2 0
23244     /* JITTER_ARG2 is intentionally not defined for a fast label. */
23245 
23246 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
23247 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
23248 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
23249 
23250 #else
23251   /* Define argument-access macros assuming that fast branches are disabled. */
23252     /* The 0th argument is a residual literal. */
23253 #if defined(JITTER_DISPATCH_NO_THREADING)
23254 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23255     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23256 #elif defined (JITTER_REPLICATE)
23257 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23258 #else
23259 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23260 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23261 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23262 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23263 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23264 #   define JITTER_ARGF0 JITTER_ARGP0
23265 
23266     /* The 1th argument is a nonresidual literal. */
23267 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
23268 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23269 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23270 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23271 #   define JITTER_ARGF1 JITTER_ARGP1
23272 
23273 #if defined(JITTER_DISPATCH_NO_THREADING)
23274 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
23275     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
23276 #elif defined (JITTER_REPLICATE)
23277 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
23278 #else
23279 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
23280 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23281 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
23282 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
23283 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
23284 #   define JITTER_ARGF2 JITTER_ARGP2
23285 
23286 # endif // #ifdef JITTER_HAVE_PATCH_IN
23287 
23288 #if defined (JITTER_PROFILE_SAMPLE)
23289   JITTER_PROFILE_SAMPLE_UPDATE
23290      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23291       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23292   /* Force the compiler not move sample-profiling instrumentation
23293      beyond this point; this way the actual user code is timed.
23294      This is still not perfect, as residuals are materialised before
23295      we arrive here, but should be adequate at least for slow VM
23296      instructions. */
23297   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23298 #endif
23299 #if defined (JITTER_PROFILE_COUNT)
23300   /* Notice that, differently from the code above, this
23301      instrumentation code *can* be reordered freely: as long as a
23302      VM instruction is counted, the count increment can be placed
23303      anyehere.  Let GCC move this code and possibly achieve better
23304      throughput by exploiting instruction-level parallelism and
23305      therefore approximate more closely a non-profiled build. */
23306   JITTER_PROFILE_COUNT_UPDATE
23307      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23308       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23309 #endif
23310 
23311 /* User-specified code, instruction-beginning-c part: beginning. */
23312 
23313 
23314 /* User-specified code, instruction-beginning-c part: end */
23315 
23316 
23317     /* User code for primitive/nR/n1/fR . */
23318 
23319     /* The error-handling label is not actually used in this case: the
23320        primitive function, written in C, has its own handling.  It's
23321        harmless to have it anyway, as it makes the C code generator
23322        more uniform. */
23323     jitterlisp_primitive_function p
23324       = (jitterlisp_primitive_function) JITTER_ARGP0;
23325     const jitter_uint in_arity = JITTER_ARGN1;
23326     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
23327     //asm volatile ("nop");
23328     jitterlisp_object *first_arg
23329       // FIXME: add a stack operator to compute this address.
23330       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
23331     /* This workaround is needed for Alpha.  I have macros to make this nicer in
23332        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
23333        Jitter. */
23334 /*
23335     void *saved_gp;
23336     asm volatile ("stq $gp, %[saved_gp]"
23337                   : [saved_gp] "=o" (saved_gp),
23338                     "+X" (p));
23339 */
23340     jitterlisp_object res = p (first_arg);
23341     /* Second part of the Alpha workaround. */
23342 /*
23343     asm volatile ("ldq $gp, %[saved_gp]"
23344                   : "+X" (res)
23345                   : [saved_gp] "o" (saved_gp));
23346 */
23347 
23348     jitter_uint i;
23349     // Remove as many elements as the primitive in-arity, but not more:
23350     // the top unspecified value we pushed will be replaced with the result.
23351     for (i = 0; i < in_arity; i ++)
23352       JITTER_NIP_MAINSTACK();
23353     //asm ("unop" : "+g" (jitter_state_runtime));
23354     JITTER_TOP_MAINSTACK() = res;
23355 
23356     /* End of the user code for primitive/nR/n1/fR . */
23357 
23358 /* User-specified code, instruction-end-c part: beginning. */
23359 
23360 
23361 /* User-specified code, instruction-end-c part: end */
23362 
23363     /* Undefine the primitive/nR/n1/fR argument macros so they can't be used
23364        by mistake in the instruction body coming next. */
23365 #   undef JITTER_SLOW_REGISTER_OFFSET0
23366 #   undef JITTER_ARG0
23367 #   undef JITTER_ARGN0
23368 #   undef JITTER_ARGU0
23369 #   undef JITTER_ARGP0
23370 #   undef JITTER_ARGF0
23371 #   undef JITTER_SLOW_REGISTER_OFFSET1
23372 #   undef JITTER_ARG1
23373 #   undef JITTER_ARGN1
23374 #   undef JITTER_ARGU1
23375 #   undef JITTER_ARGP1
23376 #   undef JITTER_ARGF1
23377 #   undef JITTER_SLOW_REGISTER_OFFSET2
23378 #   undef JITTER_ARG2
23379 #   undef JITTER_ARGN2
23380 #   undef JITTER_ARGU2
23381 #   undef JITTER_ARGP2
23382 #   undef JITTER_ARGF2
23383 
23384 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23385 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23386 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23387 
23388   }
23389  JITTER_INSTRUCTION_EPILOG_(primitive/nR/n1/fR, primitive__nR__n1__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23390 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23391 
23392   JITTER_INSTRUCTION_PROLOG_(primitive/nR/n2/fR, primitive__nR__n2__fR, cold)
23393   {
23394     /* This specialized instruction is not a replacement. */
23395 #   undef JITTER_BRANCH_FAST
23396 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23397 #   undef JITTER_BRANCH_FAST_IF_ZERO
23398 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23399 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23400 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23401 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23402 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23403 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23404 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23405 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23406 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23407 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23408 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23409 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23410 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23411 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23412 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23413 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23414 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23415 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23416 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23417 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23418 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23419 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23420 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23421 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23422 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23423 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23424 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23425 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23426 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23427 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23428 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23429 #   undef JITTER_BRANCH_FAST_IF_AND
23430 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23431 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23432 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23433 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23434 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23435 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23436 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23437 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23438 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23439 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23440 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23441 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23442 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23443 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23444 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23445 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23446 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23447 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23448 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23449 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23450 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23451 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23452 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23453 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23454 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23455 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23456 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23457 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23458 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23459 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       119
23460 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n2/fR
23461 
23462 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n2__fR
23463 
23464   /* The residual arity varies depending on whether we have fast labels. */
23465 #ifdef JITTER_HAVE_PATCH_IN
23466   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
23467 #else
23468   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
23469 #endif // #ifdef JITTER_HAVE_PATCH_IN
23470 
23471   /* Define argument-access macros for primitive/nR/n2/fR . */
23472 #ifdef JITTER_HAVE_PATCH_IN
23473   /* Define argument-access macros assuming that fast branches are enabled. */
23474     /* The 0th argument is a residual literal. */
23475 #if defined(JITTER_DISPATCH_NO_THREADING)
23476 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23477     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23478 #elif defined (JITTER_REPLICATE)
23479 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23480 #else
23481 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23482 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23483 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23484 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23485 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23486 
23487     /* The 1th argument is a nonresidual literal. */
23488 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
23489 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23490 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23491 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23492 
23493     /* The 2th argument is a "residual" fast label.  Define its
23494        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
23495        so that at replication time we know what instruction address to patch in. */
23496 #   define JITTER_ARGF2 0
23497     /* JITTER_ARG2 is intentionally not defined for a fast label. */
23498 
23499 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
23500 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
23501 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
23502 
23503 #else
23504   /* Define argument-access macros assuming that fast branches are disabled. */
23505     /* The 0th argument is a residual literal. */
23506 #if defined(JITTER_DISPATCH_NO_THREADING)
23507 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23508     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23509 #elif defined (JITTER_REPLICATE)
23510 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23511 #else
23512 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23513 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23514 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23515 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23516 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23517 #   define JITTER_ARGF0 JITTER_ARGP0
23518 
23519     /* The 1th argument is a nonresidual literal. */
23520 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
23521 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23522 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23523 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23524 #   define JITTER_ARGF1 JITTER_ARGP1
23525 
23526 #if defined(JITTER_DISPATCH_NO_THREADING)
23527 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
23528     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
23529 #elif defined (JITTER_REPLICATE)
23530 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
23531 #else
23532 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
23533 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23534 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
23535 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
23536 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
23537 #   define JITTER_ARGF2 JITTER_ARGP2
23538 
23539 # endif // #ifdef JITTER_HAVE_PATCH_IN
23540 
23541 #if defined (JITTER_PROFILE_SAMPLE)
23542   JITTER_PROFILE_SAMPLE_UPDATE
23543      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23544       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23545   /* Force the compiler not move sample-profiling instrumentation
23546      beyond this point; this way the actual user code is timed.
23547      This is still not perfect, as residuals are materialised before
23548      we arrive here, but should be adequate at least for slow VM
23549      instructions. */
23550   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23551 #endif
23552 #if defined (JITTER_PROFILE_COUNT)
23553   /* Notice that, differently from the code above, this
23554      instrumentation code *can* be reordered freely: as long as a
23555      VM instruction is counted, the count increment can be placed
23556      anyehere.  Let GCC move this code and possibly achieve better
23557      throughput by exploiting instruction-level parallelism and
23558      therefore approximate more closely a non-profiled build. */
23559   JITTER_PROFILE_COUNT_UPDATE
23560      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23561       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23562 #endif
23563 
23564 /* User-specified code, instruction-beginning-c part: beginning. */
23565 
23566 
23567 /* User-specified code, instruction-beginning-c part: end */
23568 
23569 
23570     /* User code for primitive/nR/n2/fR . */
23571 
23572     /* The error-handling label is not actually used in this case: the
23573        primitive function, written in C, has its own handling.  It's
23574        harmless to have it anyway, as it makes the C code generator
23575        more uniform. */
23576     jitterlisp_primitive_function p
23577       = (jitterlisp_primitive_function) JITTER_ARGP0;
23578     const jitter_uint in_arity = JITTER_ARGN1;
23579     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
23580     //asm volatile ("nop");
23581     jitterlisp_object *first_arg
23582       // FIXME: add a stack operator to compute this address.
23583       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
23584     /* This workaround is needed for Alpha.  I have macros to make this nicer in
23585        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
23586        Jitter. */
23587 /*
23588     void *saved_gp;
23589     asm volatile ("stq $gp, %[saved_gp]"
23590                   : [saved_gp] "=o" (saved_gp),
23591                     "+X" (p));
23592 */
23593     jitterlisp_object res = p (first_arg);
23594     /* Second part of the Alpha workaround. */
23595 /*
23596     asm volatile ("ldq $gp, %[saved_gp]"
23597                   : "+X" (res)
23598                   : [saved_gp] "o" (saved_gp));
23599 */
23600 
23601     jitter_uint i;
23602     // Remove as many elements as the primitive in-arity, but not more:
23603     // the top unspecified value we pushed will be replaced with the result.
23604     for (i = 0; i < in_arity; i ++)
23605       JITTER_NIP_MAINSTACK();
23606     //asm ("unop" : "+g" (jitter_state_runtime));
23607     JITTER_TOP_MAINSTACK() = res;
23608 
23609     /* End of the user code for primitive/nR/n2/fR . */
23610 
23611 /* User-specified code, instruction-end-c part: beginning. */
23612 
23613 
23614 /* User-specified code, instruction-end-c part: end */
23615 
23616     /* Undefine the primitive/nR/n2/fR argument macros so they can't be used
23617        by mistake in the instruction body coming next. */
23618 #   undef JITTER_SLOW_REGISTER_OFFSET0
23619 #   undef JITTER_ARG0
23620 #   undef JITTER_ARGN0
23621 #   undef JITTER_ARGU0
23622 #   undef JITTER_ARGP0
23623 #   undef JITTER_ARGF0
23624 #   undef JITTER_SLOW_REGISTER_OFFSET1
23625 #   undef JITTER_ARG1
23626 #   undef JITTER_ARGN1
23627 #   undef JITTER_ARGU1
23628 #   undef JITTER_ARGP1
23629 #   undef JITTER_ARGF1
23630 #   undef JITTER_SLOW_REGISTER_OFFSET2
23631 #   undef JITTER_ARG2
23632 #   undef JITTER_ARGN2
23633 #   undef JITTER_ARGU2
23634 #   undef JITTER_ARGP2
23635 #   undef JITTER_ARGF2
23636 
23637 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23638 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23639 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23640 
23641   }
23642  JITTER_INSTRUCTION_EPILOG_(primitive/nR/n2/fR, primitive__nR__n2__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23643 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23644 
23645   JITTER_INSTRUCTION_PROLOG_(primitive/nR/n3/fR, primitive__nR__n3__fR, cold)
23646   {
23647     /* This specialized instruction is not a replacement. */
23648 #   undef JITTER_BRANCH_FAST
23649 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23650 #   undef JITTER_BRANCH_FAST_IF_ZERO
23651 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23652 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23653 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23654 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23655 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23656 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23657 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23658 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23659 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23660 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23661 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23662 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23663 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23664 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23665 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23666 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23667 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23668 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23669 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23670 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23671 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23672 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23673 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23674 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23675 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23676 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23677 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23678 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23679 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23680 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23681 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23682 #   undef JITTER_BRANCH_FAST_IF_AND
23683 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23684 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23685 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23686 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23687 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23688 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23689 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23690 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23691 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23692 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23693 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23694 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23695 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23696 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23697 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23698 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23699 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23700 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23701 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23702 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23703 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23704 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23705 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23706 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23707 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23708 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23709 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23710 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23711 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23712 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       120
23713 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n3/fR
23714 
23715 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n3__fR
23716 
23717   /* The residual arity varies depending on whether we have fast labels. */
23718 #ifdef JITTER_HAVE_PATCH_IN
23719   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
23720 #else
23721   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
23722 #endif // #ifdef JITTER_HAVE_PATCH_IN
23723 
23724   /* Define argument-access macros for primitive/nR/n3/fR . */
23725 #ifdef JITTER_HAVE_PATCH_IN
23726   /* Define argument-access macros assuming that fast branches are enabled. */
23727     /* The 0th argument is a residual literal. */
23728 #if defined(JITTER_DISPATCH_NO_THREADING)
23729 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23730     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23731 #elif defined (JITTER_REPLICATE)
23732 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23733 #else
23734 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23735 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23736 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23737 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23738 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23739 
23740     /* The 1th argument is a nonresidual literal. */
23741 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
23742 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23743 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23744 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23745 
23746     /* The 2th argument is a "residual" fast label.  Define its
23747        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
23748        so that at replication time we know what instruction address to patch in. */
23749 #   define JITTER_ARGF2 0
23750     /* JITTER_ARG2 is intentionally not defined for a fast label. */
23751 
23752 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
23753 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
23754 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
23755 
23756 #else
23757   /* Define argument-access macros assuming that fast branches are disabled. */
23758     /* The 0th argument is a residual literal. */
23759 #if defined(JITTER_DISPATCH_NO_THREADING)
23760 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23761     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23762 #elif defined (JITTER_REPLICATE)
23763 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23764 #else
23765 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23766 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23767 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23768 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23769 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23770 #   define JITTER_ARGF0 JITTER_ARGP0
23771 
23772     /* The 1th argument is a nonresidual literal. */
23773 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
23774 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23775 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23776 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23777 #   define JITTER_ARGF1 JITTER_ARGP1
23778 
23779 #if defined(JITTER_DISPATCH_NO_THREADING)
23780 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
23781     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
23782 #elif defined (JITTER_REPLICATE)
23783 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
23784 #else
23785 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
23786 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23787 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
23788 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
23789 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
23790 #   define JITTER_ARGF2 JITTER_ARGP2
23791 
23792 # endif // #ifdef JITTER_HAVE_PATCH_IN
23793 
23794 #if defined (JITTER_PROFILE_SAMPLE)
23795   JITTER_PROFILE_SAMPLE_UPDATE
23796      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23797       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23798   /* Force the compiler not move sample-profiling instrumentation
23799      beyond this point; this way the actual user code is timed.
23800      This is still not perfect, as residuals are materialised before
23801      we arrive here, but should be adequate at least for slow VM
23802      instructions. */
23803   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
23804 #endif
23805 #if defined (JITTER_PROFILE_COUNT)
23806   /* Notice that, differently from the code above, this
23807      instrumentation code *can* be reordered freely: as long as a
23808      VM instruction is counted, the count increment can be placed
23809      anyehere.  Let GCC move this code and possibly achieve better
23810      throughput by exploiting instruction-level parallelism and
23811      therefore approximate more closely a non-profiled build. */
23812   JITTER_PROFILE_COUNT_UPDATE
23813      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
23814       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
23815 #endif
23816 
23817 /* User-specified code, instruction-beginning-c part: beginning. */
23818 
23819 
23820 /* User-specified code, instruction-beginning-c part: end */
23821 
23822 
23823     /* User code for primitive/nR/n3/fR . */
23824 
23825     /* The error-handling label is not actually used in this case: the
23826        primitive function, written in C, has its own handling.  It's
23827        harmless to have it anyway, as it makes the C code generator
23828        more uniform. */
23829     jitterlisp_primitive_function p
23830       = (jitterlisp_primitive_function) JITTER_ARGP0;
23831     const jitter_uint in_arity = JITTER_ARGN1;
23832     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
23833     //asm volatile ("nop");
23834     jitterlisp_object *first_arg
23835       // FIXME: add a stack operator to compute this address.
23836       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
23837     /* This workaround is needed for Alpha.  I have macros to make this nicer in
23838        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
23839        Jitter. */
23840 /*
23841     void *saved_gp;
23842     asm volatile ("stq $gp, %[saved_gp]"
23843                   : [saved_gp] "=o" (saved_gp),
23844                     "+X" (p));
23845 */
23846     jitterlisp_object res = p (first_arg);
23847     /* Second part of the Alpha workaround. */
23848 /*
23849     asm volatile ("ldq $gp, %[saved_gp]"
23850                   : "+X" (res)
23851                   : [saved_gp] "o" (saved_gp));
23852 */
23853 
23854     jitter_uint i;
23855     // Remove as many elements as the primitive in-arity, but not more:
23856     // the top unspecified value we pushed will be replaced with the result.
23857     for (i = 0; i < in_arity; i ++)
23858       JITTER_NIP_MAINSTACK();
23859     //asm ("unop" : "+g" (jitter_state_runtime));
23860     JITTER_TOP_MAINSTACK() = res;
23861 
23862     /* End of the user code for primitive/nR/n3/fR . */
23863 
23864 /* User-specified code, instruction-end-c part: beginning. */
23865 
23866 
23867 /* User-specified code, instruction-end-c part: end */
23868 
23869     /* Undefine the primitive/nR/n3/fR argument macros so they can't be used
23870        by mistake in the instruction body coming next. */
23871 #   undef JITTER_SLOW_REGISTER_OFFSET0
23872 #   undef JITTER_ARG0
23873 #   undef JITTER_ARGN0
23874 #   undef JITTER_ARGU0
23875 #   undef JITTER_ARGP0
23876 #   undef JITTER_ARGF0
23877 #   undef JITTER_SLOW_REGISTER_OFFSET1
23878 #   undef JITTER_ARG1
23879 #   undef JITTER_ARGN1
23880 #   undef JITTER_ARGU1
23881 #   undef JITTER_ARGP1
23882 #   undef JITTER_ARGF1
23883 #   undef JITTER_SLOW_REGISTER_OFFSET2
23884 #   undef JITTER_ARG2
23885 #   undef JITTER_ARGN2
23886 #   undef JITTER_ARGU2
23887 #   undef JITTER_ARGP2
23888 #   undef JITTER_ARGF2
23889 
23890 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
23891 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
23892 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
23893 
23894   }
23895  JITTER_INSTRUCTION_EPILOG_(primitive/nR/n3/fR, primitive__nR__n3__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
23896 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
23897 
23898   JITTER_INSTRUCTION_PROLOG_(primitive/nR/n4/fR, primitive__nR__n4__fR, cold)
23899   {
23900     /* This specialized instruction is not a replacement. */
23901 #   undef JITTER_BRANCH_FAST
23902 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
23903 #   undef JITTER_BRANCH_FAST_IF_ZERO
23904 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
23905 #   undef JITTER_BRANCH_FAST_IF_NONZERO
23906 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
23907 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
23908 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
23909 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
23910 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
23911 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
23912 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
23913 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
23914 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
23915 #   undef JITTER_BRANCH_FAST_IF_EQUAL
23916 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
23917 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
23918 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
23919 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
23920 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
23921 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23922 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
23923 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23924 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
23925 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23926 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
23927 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23928 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
23929 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23930 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
23931 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23932 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
23933 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23934 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
23935 #   undef JITTER_BRANCH_FAST_IF_AND
23936 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
23937 #   undef JITTER_BRANCH_FAST_IF_NOTAND
23938 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
23939 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23940 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
23941 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23942 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
23943 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23944 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
23945 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23946 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
23947 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23948 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
23949 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23950 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
23951 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23952 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
23953 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23954 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
23955 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23956 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
23957 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23958 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
23959 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23960 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
23961 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23962 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
23963 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23964 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
23965 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       121
23966 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/n4/fR
23967 
23968 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__n4__fR
23969 
23970   /* The residual arity varies depending on whether we have fast labels. */
23971 #ifdef JITTER_HAVE_PATCH_IN
23972   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
23973 #else
23974   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
23975 #endif // #ifdef JITTER_HAVE_PATCH_IN
23976 
23977   /* Define argument-access macros for primitive/nR/n4/fR . */
23978 #ifdef JITTER_HAVE_PATCH_IN
23979   /* Define argument-access macros assuming that fast branches are enabled. */
23980     /* The 0th argument is a residual literal. */
23981 #if defined(JITTER_DISPATCH_NO_THREADING)
23982 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
23983     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
23984 #elif defined (JITTER_REPLICATE)
23985 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
23986 #else
23987 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
23988 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
23989 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
23990 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
23991 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
23992 
23993     /* The 1th argument is a nonresidual literal. */
23994 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
23995 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
23996 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
23997 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
23998 
23999     /* The 2th argument is a "residual" fast label.  Define its
24000        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
24001        so that at replication time we know what instruction address to patch in. */
24002 #   define JITTER_ARGF2 0
24003     /* JITTER_ARG2 is intentionally not defined for a fast label. */
24004 
24005 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
24006 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
24007 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
24008 
24009 #else
24010   /* Define argument-access macros assuming that fast branches are disabled. */
24011     /* The 0th argument is a residual literal. */
24012 #if defined(JITTER_DISPATCH_NO_THREADING)
24013 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
24014     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
24015 #elif defined (JITTER_REPLICATE)
24016 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
24017 #else
24018 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
24019 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24020 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
24021 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
24022 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
24023 #   define JITTER_ARGF0 JITTER_ARGP0
24024 
24025     /* The 1th argument is a nonresidual literal. */
24026 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
24027 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
24028 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
24029 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
24030 #   define JITTER_ARGF1 JITTER_ARGP1
24031 
24032 #if defined(JITTER_DISPATCH_NO_THREADING)
24033 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
24034     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
24035 #elif defined (JITTER_REPLICATE)
24036 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
24037 #else
24038 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
24039 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24040 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
24041 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
24042 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
24043 #   define JITTER_ARGF2 JITTER_ARGP2
24044 
24045 # endif // #ifdef JITTER_HAVE_PATCH_IN
24046 
24047 #if defined (JITTER_PROFILE_SAMPLE)
24048   JITTER_PROFILE_SAMPLE_UPDATE
24049      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24050       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24051   /* Force the compiler not move sample-profiling instrumentation
24052      beyond this point; this way the actual user code is timed.
24053      This is still not perfect, as residuals are materialised before
24054      we arrive here, but should be adequate at least for slow VM
24055      instructions. */
24056   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24057 #endif
24058 #if defined (JITTER_PROFILE_COUNT)
24059   /* Notice that, differently from the code above, this
24060      instrumentation code *can* be reordered freely: as long as a
24061      VM instruction is counted, the count increment can be placed
24062      anyehere.  Let GCC move this code and possibly achieve better
24063      throughput by exploiting instruction-level parallelism and
24064      therefore approximate more closely a non-profiled build. */
24065   JITTER_PROFILE_COUNT_UPDATE
24066      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24067       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24068 #endif
24069 
24070 /* User-specified code, instruction-beginning-c part: beginning. */
24071 
24072 
24073 /* User-specified code, instruction-beginning-c part: end */
24074 
24075 
24076     /* User code for primitive/nR/n4/fR . */
24077 
24078     /* The error-handling label is not actually used in this case: the
24079        primitive function, written in C, has its own handling.  It's
24080        harmless to have it anyway, as it makes the C code generator
24081        more uniform. */
24082     jitterlisp_primitive_function p
24083       = (jitterlisp_primitive_function) JITTER_ARGP0;
24084     const jitter_uint in_arity = JITTER_ARGN1;
24085     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
24086     //asm volatile ("nop");
24087     jitterlisp_object *first_arg
24088       // FIXME: add a stack operator to compute this address.
24089       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
24090     /* This workaround is needed for Alpha.  I have macros to make this nicer in
24091        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
24092        Jitter. */
24093 /*
24094     void *saved_gp;
24095     asm volatile ("stq $gp, %[saved_gp]"
24096                   : [saved_gp] "=o" (saved_gp),
24097                     "+X" (p));
24098 */
24099     jitterlisp_object res = p (first_arg);
24100     /* Second part of the Alpha workaround. */
24101 /*
24102     asm volatile ("ldq $gp, %[saved_gp]"
24103                   : "+X" (res)
24104                   : [saved_gp] "o" (saved_gp));
24105 */
24106 
24107     jitter_uint i;
24108     // Remove as many elements as the primitive in-arity, but not more:
24109     // the top unspecified value we pushed will be replaced with the result.
24110     for (i = 0; i < in_arity; i ++)
24111       JITTER_NIP_MAINSTACK();
24112     //asm ("unop" : "+g" (jitter_state_runtime));
24113     JITTER_TOP_MAINSTACK() = res;
24114 
24115     /* End of the user code for primitive/nR/n4/fR . */
24116 
24117 /* User-specified code, instruction-end-c part: beginning. */
24118 
24119 
24120 /* User-specified code, instruction-end-c part: end */
24121 
24122     /* Undefine the primitive/nR/n4/fR argument macros so they can't be used
24123        by mistake in the instruction body coming next. */
24124 #   undef JITTER_SLOW_REGISTER_OFFSET0
24125 #   undef JITTER_ARG0
24126 #   undef JITTER_ARGN0
24127 #   undef JITTER_ARGU0
24128 #   undef JITTER_ARGP0
24129 #   undef JITTER_ARGF0
24130 #   undef JITTER_SLOW_REGISTER_OFFSET1
24131 #   undef JITTER_ARG1
24132 #   undef JITTER_ARGN1
24133 #   undef JITTER_ARGU1
24134 #   undef JITTER_ARGP1
24135 #   undef JITTER_ARGF1
24136 #   undef JITTER_SLOW_REGISTER_OFFSET2
24137 #   undef JITTER_ARG2
24138 #   undef JITTER_ARGN2
24139 #   undef JITTER_ARGU2
24140 #   undef JITTER_ARGP2
24141 #   undef JITTER_ARGF2
24142 
24143 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24144 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24145 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24146 
24147   }
24148  JITTER_INSTRUCTION_EPILOG_(primitive/nR/n4/fR, primitive__nR__n4__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24149 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24150 
24151   JITTER_INSTRUCTION_PROLOG_(primitive/nR/nR/fR, primitive__nR__nR__fR, cold)
24152   {
24153     /* This specialized instruction is not a replacement. */
24154 #   undef JITTER_BRANCH_FAST
24155 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24156 #   undef JITTER_BRANCH_FAST_IF_ZERO
24157 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24158 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24159 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24160 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24161 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24162 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24163 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24164 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24165 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24166 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24167 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24168 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24169 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24170 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24171 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24172 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24173 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24174 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24175 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24176 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24177 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24178 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24179 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24180 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24181 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24182 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24183 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24184 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24185 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24186 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24187 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24188 #   undef JITTER_BRANCH_FAST_IF_AND
24189 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24190 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24191 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24192 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24193 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24194 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24195 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24196 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24197 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24198 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24199 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24200 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24201 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24202 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24203 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24204 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24205 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24206 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24207 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24208 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24209 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24210 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24211 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24212 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24213 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24214 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24215 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24216 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24217 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24218 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       122
24219 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive/nR/nR/fR
24220 
24221 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive__nR__nR__fR
24222 
24223   /* The residual arity varies depending on whether we have fast labels. */
24224 #ifdef JITTER_HAVE_PATCH_IN
24225   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
24226 #else
24227   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
24228 #endif // #ifdef JITTER_HAVE_PATCH_IN
24229 
24230   /* Define argument-access macros for primitive/nR/nR/fR . */
24231 #ifdef JITTER_HAVE_PATCH_IN
24232   /* Define argument-access macros assuming that fast branches are enabled. */
24233     /* The 0th argument is a residual literal. */
24234 #if defined(JITTER_DISPATCH_NO_THREADING)
24235 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
24236     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
24237 #elif defined (JITTER_REPLICATE)
24238 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
24239 #else
24240 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
24241 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24242 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
24243 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
24244 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
24245 
24246     /* The 1th argument is a residual literal. */
24247 #if defined(JITTER_DISPATCH_NO_THREADING)
24248 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
24249     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
24250 #elif defined (JITTER_REPLICATE)
24251 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
24252 #else
24253 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
24254 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24255 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
24256 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
24257 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
24258 
24259     /* The 2th argument is a "residual" fast label.  Define its
24260        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
24261        so that at replication time we know what instruction address to patch in. */
24262 #   define JITTER_ARGF2 0
24263     /* JITTER_ARG2 is intentionally not defined for a fast label. */
24264 
24265 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
24266 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
24267 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
24268 
24269 #else
24270   /* Define argument-access macros assuming that fast branches are disabled. */
24271     /* The 0th argument is a residual literal. */
24272 #if defined(JITTER_DISPATCH_NO_THREADING)
24273 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
24274     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
24275 #elif defined (JITTER_REPLICATE)
24276 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
24277 #else
24278 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
24279 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24280 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
24281 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
24282 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
24283 #   define JITTER_ARGF0 JITTER_ARGP0
24284 
24285     /* The 1th argument is a residual literal. */
24286 #if defined(JITTER_DISPATCH_NO_THREADING)
24287 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
24288     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
24289 #elif defined (JITTER_REPLICATE)
24290 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
24291 #else
24292 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
24293 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24294 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
24295 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
24296 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
24297 #   define JITTER_ARGF1 JITTER_ARGP1
24298 
24299 #if defined(JITTER_DISPATCH_NO_THREADING)
24300 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
24301     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
24302 #elif defined (JITTER_REPLICATE)
24303 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
24304 #else
24305 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
24306 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24307 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
24308 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
24309 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
24310 #   define JITTER_ARGF2 JITTER_ARGP2
24311 
24312 # endif // #ifdef JITTER_HAVE_PATCH_IN
24313 
24314 #if defined (JITTER_PROFILE_SAMPLE)
24315   JITTER_PROFILE_SAMPLE_UPDATE
24316      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24317       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24318   /* Force the compiler not move sample-profiling instrumentation
24319      beyond this point; this way the actual user code is timed.
24320      This is still not perfect, as residuals are materialised before
24321      we arrive here, but should be adequate at least for slow VM
24322      instructions. */
24323   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24324 #endif
24325 #if defined (JITTER_PROFILE_COUNT)
24326   /* Notice that, differently from the code above, this
24327      instrumentation code *can* be reordered freely: as long as a
24328      VM instruction is counted, the count increment can be placed
24329      anyehere.  Let GCC move this code and possibly achieve better
24330      throughput by exploiting instruction-level parallelism and
24331      therefore approximate more closely a non-profiled build. */
24332   JITTER_PROFILE_COUNT_UPDATE
24333      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24334       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24335 #endif
24336 
24337 /* User-specified code, instruction-beginning-c part: beginning. */
24338 
24339 
24340 /* User-specified code, instruction-beginning-c part: end */
24341 
24342 
24343     /* User code for primitive/nR/nR/fR . */
24344 
24345     /* The error-handling label is not actually used in this case: the
24346        primitive function, written in C, has its own handling.  It's
24347        harmless to have it anyway, as it makes the C code generator
24348        more uniform. */
24349     jitterlisp_primitive_function p
24350       = (jitterlisp_primitive_function) JITTER_ARGP0;
24351     const jitter_uint in_arity = JITTER_ARGN1;
24352     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
24353     //asm volatile ("nop");
24354     jitterlisp_object *first_arg
24355       // FIXME: add a stack operator to compute this address.
24356       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
24357     /* This workaround is needed for Alpha.  I have macros to make this nicer in
24358        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
24359        Jitter. */
24360 /*
24361     void *saved_gp;
24362     asm volatile ("stq $gp, %[saved_gp]"
24363                   : [saved_gp] "=o" (saved_gp),
24364                     "+X" (p));
24365 */
24366     jitterlisp_object res = p (first_arg);
24367     /* Second part of the Alpha workaround. */
24368 /*
24369     asm volatile ("ldq $gp, %[saved_gp]"
24370                   : "+X" (res)
24371                   : [saved_gp] "o" (saved_gp));
24372 */
24373 
24374     jitter_uint i;
24375     // Remove as many elements as the primitive in-arity, but not more:
24376     // the top unspecified value we pushed will be replaced with the result.
24377     for (i = 0; i < in_arity; i ++)
24378       JITTER_NIP_MAINSTACK();
24379     //asm ("unop" : "+g" (jitter_state_runtime));
24380     JITTER_TOP_MAINSTACK() = res;
24381 
24382     /* End of the user code for primitive/nR/nR/fR . */
24383 
24384 /* User-specified code, instruction-end-c part: beginning. */
24385 
24386 
24387 /* User-specified code, instruction-end-c part: end */
24388 
24389     /* Undefine the primitive/nR/nR/fR argument macros so they can't be used
24390        by mistake in the instruction body coming next. */
24391 #   undef JITTER_SLOW_REGISTER_OFFSET0
24392 #   undef JITTER_ARG0
24393 #   undef JITTER_ARGN0
24394 #   undef JITTER_ARGU0
24395 #   undef JITTER_ARGP0
24396 #   undef JITTER_ARGF0
24397 #   undef JITTER_SLOW_REGISTER_OFFSET1
24398 #   undef JITTER_ARG1
24399 #   undef JITTER_ARGN1
24400 #   undef JITTER_ARGU1
24401 #   undef JITTER_ARGP1
24402 #   undef JITTER_ARGF1
24403 #   undef JITTER_SLOW_REGISTER_OFFSET2
24404 #   undef JITTER_ARG2
24405 #   undef JITTER_ARGN2
24406 #   undef JITTER_ARGU2
24407 #   undef JITTER_ARGP2
24408 #   undef JITTER_ARGF2
24409 
24410 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24411 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24412 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24413 
24414   }
24415  JITTER_INSTRUCTION_EPILOG_(primitive/nR/nR/fR, primitive__nR__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24416 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24417 
24418   JITTER_INSTRUCTION_PROLOG_(primitive-boolean-canonicalize, primitive_mboolean_mcanonicalize, hot)
24419   {
24420     /* This specialized instruction is not a replacement. */
24421 #   undef JITTER_BRANCH_FAST
24422 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24423 #   undef JITTER_BRANCH_FAST_IF_ZERO
24424 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24425 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24426 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24427 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24428 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24429 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24430 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24431 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24432 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24433 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24434 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24435 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24436 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24437 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24438 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24439 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24440 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24441 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24442 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24443 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24444 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24445 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24446 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24447 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24448 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24449 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24450 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24451 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24452 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24453 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24454 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24455 #   undef JITTER_BRANCH_FAST_IF_AND
24456 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24457 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24458 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24459 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24460 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24461 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24462 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24463 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24464 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24465 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24466 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24467 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24468 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24469 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24470 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24471 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24472 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24473 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24474 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24475 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24476 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24477 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24478 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24479 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24480 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24481 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24482 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24483 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24484 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24485 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       123
24486 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-boolean-canonicalize
24487 
24488 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mboolean_mcanonicalize
24489 
24490   /* The residual arity for this instruction does not depend on fast labels. */
24491   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24492 
24493 
24494 #if defined (JITTER_PROFILE_SAMPLE)
24495   JITTER_PROFILE_SAMPLE_UPDATE
24496      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24497       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24498   /* Force the compiler not move sample-profiling instrumentation
24499      beyond this point; this way the actual user code is timed.
24500      This is still not perfect, as residuals are materialised before
24501      we arrive here, but should be adequate at least for slow VM
24502      instructions. */
24503   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24504 #endif
24505 #if defined (JITTER_PROFILE_COUNT)
24506   /* Notice that, differently from the code above, this
24507      instrumentation code *can* be reordered freely: as long as a
24508      VM instruction is counted, the count increment can be placed
24509      anyehere.  Let GCC move this code and possibly achieve better
24510      throughput by exploiting instruction-level parallelism and
24511      therefore approximate more closely a non-profiled build. */
24512   JITTER_PROFILE_COUNT_UPDATE
24513      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24514       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24515 #endif
24516 
24517 /* User-specified code, instruction-beginning-c part: beginning. */
24518 
24519 
24520 /* User-specified code, instruction-beginning-c part: end */
24521 
24522 
24523     /* User code for primitive-boolean-canonicalize . */
24524 
24525     JITTERLISP_BOOLEAN_CANONICALIZE_(JITTER_TOP_MAINSTACK(),
24526                                      JITTER_TOP_MAINSTACK());
24527 
24528     /* End of the user code for primitive-boolean-canonicalize . */
24529 
24530 /* User-specified code, instruction-end-c part: beginning. */
24531 
24532 
24533 /* User-specified code, instruction-end-c part: end */
24534 
24535     /* Undefine the primitive-boolean-canonicalize argument macros so they can't be used
24536        by mistake in the instruction body coming next. */
24537 
24538 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24539 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24540 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24541 
24542   }
24543  JITTER_INSTRUCTION_EPILOG_(primitive-boolean-canonicalize, primitive_mboolean_mcanonicalize, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24544 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24545 
24546   JITTER_INSTRUCTION_PROLOG_(primitive-box, primitive_mbox, hot)
24547   {
24548     /* This specialized instruction is not a replacement. */
24549 #   undef JITTER_BRANCH_FAST
24550 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24551 #   undef JITTER_BRANCH_FAST_IF_ZERO
24552 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24553 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24554 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24555 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24556 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24557 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24558 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24559 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24560 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24561 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24562 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24563 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24564 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24565 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24566 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24567 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24568 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24569 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24570 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24571 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24572 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24573 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24574 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24575 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24576 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24577 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24578 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24579 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24580 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24581 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24582 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24583 #   undef JITTER_BRANCH_FAST_IF_AND
24584 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24585 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24586 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24587 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24588 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24589 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24590 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24591 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24592 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24593 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24594 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24595 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24596 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24597 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24598 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24599 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24600 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24601 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24602 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24603 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24604 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24605 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24606 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24607 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24608 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24609 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24610 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24611 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24612 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24613 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       124
24614 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-box
24615 
24616 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mbox
24617 
24618   /* The residual arity for this instruction does not depend on fast labels. */
24619   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24620 
24621 
24622 #if defined (JITTER_PROFILE_SAMPLE)
24623   JITTER_PROFILE_SAMPLE_UPDATE
24624      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24625       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24626   /* Force the compiler not move sample-profiling instrumentation
24627      beyond this point; this way the actual user code is timed.
24628      This is still not perfect, as residuals are materialised before
24629      we arrive here, but should be adequate at least for slow VM
24630      instructions. */
24631   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24632 #endif
24633 #if defined (JITTER_PROFILE_COUNT)
24634   /* Notice that, differently from the code above, this
24635      instrumentation code *can* be reordered freely: as long as a
24636      VM instruction is counted, the count increment can be placed
24637      anyehere.  Let GCC move this code and possibly achieve better
24638      throughput by exploiting instruction-level parallelism and
24639      therefore approximate more closely a non-profiled build. */
24640   JITTER_PROFILE_COUNT_UPDATE
24641      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24642       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24643 #endif
24644 
24645 /* User-specified code, instruction-beginning-c part: beginning. */
24646 
24647 
24648 /* User-specified code, instruction-beginning-c part: end */
24649 
24650 
24651     /* User code for primitive-box . */
24652 
24653     JITTERLISP_BOX_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
24654 
24655     /* End of the user code for primitive-box . */
24656 
24657 /* User-specified code, instruction-end-c part: beginning. */
24658 
24659 
24660 /* User-specified code, instruction-end-c part: end */
24661 
24662     /* Undefine the primitive-box argument macros so they can't be used
24663        by mistake in the instruction body coming next. */
24664 
24665 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24666 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24667 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24668 
24669   }
24670  JITTER_INSTRUCTION_EPILOG_(primitive-box, primitive_mbox, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24671 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24672 
24673   JITTER_INSTRUCTION_PROLOG_(primitive-box-get/fR, primitive_mbox_mget__fR, hot)
24674   {
24675     /* This specialized instruction is not a replacement. */
24676 #   undef JITTER_BRANCH_FAST
24677 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24678 #   undef JITTER_BRANCH_FAST_IF_ZERO
24679 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24680 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24681 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24682 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24683 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24684 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24685 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24686 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24687 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24688 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24689 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24690 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24691 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24692 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24693 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24694 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24695 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24696 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24697 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24698 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24699 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24700 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24701 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24702 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24703 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24704 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24705 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24706 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24707 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24708 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24709 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24710 #   undef JITTER_BRANCH_FAST_IF_AND
24711 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24712 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24713 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24714 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24715 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24716 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24717 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24718 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24719 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24720 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24721 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24722 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24723 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24724 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24725 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24726 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24727 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24728 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24729 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24730 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24731 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24732 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24733 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24734 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24735 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24736 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24737 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24738 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24739 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24740 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       125
24741 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-box-get/fR
24742 
24743 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mbox_mget__fR
24744 
24745   /* The residual arity varies depending on whether we have fast labels. */
24746 #ifdef JITTER_HAVE_PATCH_IN
24747   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24748 #else
24749   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
24750 #endif // #ifdef JITTER_HAVE_PATCH_IN
24751 
24752   /* Define argument-access macros for primitive-box-get/fR . */
24753 #ifdef JITTER_HAVE_PATCH_IN
24754   /* Define argument-access macros assuming that fast branches are enabled. */
24755     /* The 0th argument is a "residual" fast label.  Define its
24756        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
24757        so that at replication time we know what instruction address to patch in. */
24758 #   define JITTER_ARGF0 0
24759     /* JITTER_ARG0 is intentionally not defined for a fast label. */
24760 
24761 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
24762 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
24763 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
24764 
24765 #else
24766   /* Define argument-access macros assuming that fast branches are disabled. */
24767 #if defined(JITTER_DISPATCH_NO_THREADING)
24768 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
24769     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
24770 #elif defined (JITTER_REPLICATE)
24771 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
24772 #else
24773 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
24774 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24775 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
24776 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
24777 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
24778 #   define JITTER_ARGF0 JITTER_ARGP0
24779 
24780 # endif // #ifdef JITTER_HAVE_PATCH_IN
24781 
24782 #if defined (JITTER_PROFILE_SAMPLE)
24783   JITTER_PROFILE_SAMPLE_UPDATE
24784      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24785       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24786   /* Force the compiler not move sample-profiling instrumentation
24787      beyond this point; this way the actual user code is timed.
24788      This is still not perfect, as residuals are materialised before
24789      we arrive here, but should be adequate at least for slow VM
24790      instructions. */
24791   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24792 #endif
24793 #if defined (JITTER_PROFILE_COUNT)
24794   /* Notice that, differently from the code above, this
24795      instrumentation code *can* be reordered freely: as long as a
24796      VM instruction is counted, the count increment can be placed
24797      anyehere.  Let GCC move this code and possibly achieve better
24798      throughput by exploiting instruction-level parallelism and
24799      therefore approximate more closely a non-profiled build. */
24800   JITTER_PROFILE_COUNT_UPDATE
24801      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24802       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24803 #endif
24804 
24805 /* User-specified code, instruction-beginning-c part: beginning. */
24806 
24807 
24808 /* User-specified code, instruction-beginning-c part: end */
24809 
24810 
24811     /* User code for primitive-box-get/fR . */
24812 
24813     JITTERLISPVM_CHECK_TYPES_1(BOX, JITTER_ARGF0);
24814     JITTERLISP_BOX_GET_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
24815 
24816     /* End of the user code for primitive-box-get/fR . */
24817 
24818 /* User-specified code, instruction-end-c part: beginning. */
24819 
24820 
24821 /* User-specified code, instruction-end-c part: end */
24822 
24823     /* Undefine the primitive-box-get/fR argument macros so they can't be used
24824        by mistake in the instruction body coming next. */
24825 #   undef JITTER_SLOW_REGISTER_OFFSET0
24826 #   undef JITTER_ARG0
24827 #   undef JITTER_ARGN0
24828 #   undef JITTER_ARGU0
24829 #   undef JITTER_ARGP0
24830 #   undef JITTER_ARGF0
24831 
24832 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
24833 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
24834 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
24835 
24836   }
24837  JITTER_INSTRUCTION_EPILOG_(primitive-box-get/fR, primitive_mbox_mget__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
24838 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
24839 
24840   JITTER_INSTRUCTION_PROLOG_(primitive-box-setb-special/fR, primitive_mbox_msetb_mspecial__fR, hot)
24841   {
24842     /* This specialized instruction is not a replacement. */
24843 #   undef JITTER_BRANCH_FAST
24844 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
24845 #   undef JITTER_BRANCH_FAST_IF_ZERO
24846 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
24847 #   undef JITTER_BRANCH_FAST_IF_NONZERO
24848 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
24849 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
24850 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
24851 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
24852 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
24853 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
24854 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
24855 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
24856 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
24857 #   undef JITTER_BRANCH_FAST_IF_EQUAL
24858 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
24859 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
24860 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
24861 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
24862 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
24863 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24864 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
24865 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24866 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
24867 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24868 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
24869 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24870 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
24871 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24872 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
24873 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24874 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
24875 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24876 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
24877 #   undef JITTER_BRANCH_FAST_IF_AND
24878 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
24879 #   undef JITTER_BRANCH_FAST_IF_NOTAND
24880 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
24881 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24882 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
24883 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24884 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
24885 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24886 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
24887 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24888 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
24889 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24890 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
24891 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24892 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
24893 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24894 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
24895 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24896 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
24897 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24898 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
24899 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24900 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
24901 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24902 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
24903 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24904 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
24905 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24906 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
24907 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       126
24908 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-box-setb-special/fR
24909 
24910 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mbox_msetb_mspecial__fR
24911 
24912   /* The residual arity varies depending on whether we have fast labels. */
24913 #ifdef JITTER_HAVE_PATCH_IN
24914   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
24915 #else
24916   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
24917 #endif // #ifdef JITTER_HAVE_PATCH_IN
24918 
24919   /* Define argument-access macros for primitive-box-setb-special/fR . */
24920 #ifdef JITTER_HAVE_PATCH_IN
24921   /* Define argument-access macros assuming that fast branches are enabled. */
24922     /* The 0th argument is a "residual" fast label.  Define its
24923        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
24924        so that at replication time we know what instruction address to patch in. */
24925 #   define JITTER_ARGF0 0
24926     /* JITTER_ARG0 is intentionally not defined for a fast label. */
24927 
24928 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
24929 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
24930 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
24931 
24932 #else
24933   /* Define argument-access macros assuming that fast branches are disabled. */
24934 #if defined(JITTER_DISPATCH_NO_THREADING)
24935 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
24936     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
24937 #elif defined (JITTER_REPLICATE)
24938 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
24939 #else
24940 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
24941 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
24942 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
24943 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
24944 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
24945 #   define JITTER_ARGF0 JITTER_ARGP0
24946 
24947 # endif // #ifdef JITTER_HAVE_PATCH_IN
24948 
24949 #if defined (JITTER_PROFILE_SAMPLE)
24950   JITTER_PROFILE_SAMPLE_UPDATE
24951      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24952       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24953   /* Force the compiler not move sample-profiling instrumentation
24954      beyond this point; this way the actual user code is timed.
24955      This is still not perfect, as residuals are materialised before
24956      we arrive here, but should be adequate at least for slow VM
24957      instructions. */
24958   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
24959 #endif
24960 #if defined (JITTER_PROFILE_COUNT)
24961   /* Notice that, differently from the code above, this
24962      instrumentation code *can* be reordered freely: as long as a
24963      VM instruction is counted, the count increment can be placed
24964      anyehere.  Let GCC move this code and possibly achieve better
24965      throughput by exploiting instruction-level parallelism and
24966      therefore approximate more closely a non-profiled build. */
24967   JITTER_PROFILE_COUNT_UPDATE
24968      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
24969       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
24970 #endif
24971 
24972 /* User-specified code, instruction-beginning-c part: beginning. */
24973 
24974 
24975 /* User-specified code, instruction-beginning-c part: end */
24976 
24977 
24978     /* User code for primitive-box-setb-special/fR . */
24979 
24980     JITTERLISPVM_CHECK_TYPES_2(BOX, ANYTHING, JITTER_ARGF0);
24981     jitterlisp_object useless __attribute__ ((unused));
24982     JITTERLISP_BOX_SETB_(useless,
24983                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
24984     /* Leave the two operands on the stack. */
24985 
24986     /* End of the user code for primitive-box-setb-special/fR . */
24987 
24988 /* User-specified code, instruction-end-c part: beginning. */
24989 
24990 
24991 /* User-specified code, instruction-end-c part: end */
24992 
24993     /* Undefine the primitive-box-setb-special/fR argument macros so they can't be used
24994        by mistake in the instruction body coming next. */
24995 #   undef JITTER_SLOW_REGISTER_OFFSET0
24996 #   undef JITTER_ARG0
24997 #   undef JITTER_ARGN0
24998 #   undef JITTER_ARGU0
24999 #   undef JITTER_ARGP0
25000 #   undef JITTER_ARGF0
25001 
25002 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25003 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25004 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25005 
25006   }
25007  JITTER_INSTRUCTION_EPILOG_(primitive-box-setb-special/fR, primitive_mbox_msetb_mspecial__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25008 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25009 
25010   JITTER_INSTRUCTION_PROLOG_(primitive-car/fR, primitive_mcar__fR, hot)
25011   {
25012     /* This specialized instruction is not a replacement. */
25013 #   undef JITTER_BRANCH_FAST
25014 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25015 #   undef JITTER_BRANCH_FAST_IF_ZERO
25016 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25017 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25018 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25019 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25020 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25021 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25022 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25023 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25024 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25025 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25026 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25027 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25028 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25029 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25030 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25031 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25032 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25033 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25034 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25035 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25036 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25037 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25038 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25039 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25040 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25041 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25042 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25043 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25044 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25045 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25046 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25047 #   undef JITTER_BRANCH_FAST_IF_AND
25048 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25049 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25050 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25051 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25052 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25053 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25054 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25055 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25056 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25057 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25058 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25059 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25060 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25061 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25062 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25063 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25064 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25065 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25066 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25067 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25068 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25069 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25070 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25071 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25072 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25073 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25074 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25075 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25076 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25077 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       127
25078 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-car/fR
25079 
25080 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcar__fR
25081 
25082   /* The residual arity varies depending on whether we have fast labels. */
25083 #ifdef JITTER_HAVE_PATCH_IN
25084   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25085 #else
25086   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
25087 #endif // #ifdef JITTER_HAVE_PATCH_IN
25088 
25089   /* Define argument-access macros for primitive-car/fR . */
25090 #ifdef JITTER_HAVE_PATCH_IN
25091   /* Define argument-access macros assuming that fast branches are enabled. */
25092     /* The 0th argument is a "residual" fast label.  Define its
25093        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
25094        so that at replication time we know what instruction address to patch in. */
25095 #   define JITTER_ARGF0 0
25096     /* JITTER_ARG0 is intentionally not defined for a fast label. */
25097 
25098 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
25099 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
25100 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
25101 
25102 #else
25103   /* Define argument-access macros assuming that fast branches are disabled. */
25104 #if defined(JITTER_DISPATCH_NO_THREADING)
25105 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
25106     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
25107 #elif defined (JITTER_REPLICATE)
25108 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
25109 #else
25110 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
25111 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
25112 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
25113 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
25114 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
25115 #   define JITTER_ARGF0 JITTER_ARGP0
25116 
25117 # endif // #ifdef JITTER_HAVE_PATCH_IN
25118 
25119 #if defined (JITTER_PROFILE_SAMPLE)
25120   JITTER_PROFILE_SAMPLE_UPDATE
25121      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25122       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25123   /* Force the compiler not move sample-profiling instrumentation
25124      beyond this point; this way the actual user code is timed.
25125      This is still not perfect, as residuals are materialised before
25126      we arrive here, but should be adequate at least for slow VM
25127      instructions. */
25128   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25129 #endif
25130 #if defined (JITTER_PROFILE_COUNT)
25131   /* Notice that, differently from the code above, this
25132      instrumentation code *can* be reordered freely: as long as a
25133      VM instruction is counted, the count increment can be placed
25134      anyehere.  Let GCC move this code and possibly achieve better
25135      throughput by exploiting instruction-level parallelism and
25136      therefore approximate more closely a non-profiled build. */
25137   JITTER_PROFILE_COUNT_UPDATE
25138      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25139       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25140 #endif
25141 
25142 /* User-specified code, instruction-beginning-c part: beginning. */
25143 
25144 
25145 /* User-specified code, instruction-beginning-c part: end */
25146 
25147 
25148     /* User code for primitive-car/fR . */
25149 
25150     JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
25151     JITTERLISP_CAR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
25152 
25153     /* End of the user code for primitive-car/fR . */
25154 
25155 /* User-specified code, instruction-end-c part: beginning. */
25156 
25157 
25158 /* User-specified code, instruction-end-c part: end */
25159 
25160     /* Undefine the primitive-car/fR argument macros so they can't be used
25161        by mistake in the instruction body coming next. */
25162 #   undef JITTER_SLOW_REGISTER_OFFSET0
25163 #   undef JITTER_ARG0
25164 #   undef JITTER_ARGN0
25165 #   undef JITTER_ARGU0
25166 #   undef JITTER_ARGP0
25167 #   undef JITTER_ARGF0
25168 
25169 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25170 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25171 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25172 
25173   }
25174  JITTER_INSTRUCTION_EPILOG_(primitive-car/fR, primitive_mcar__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25175 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25176 
25177   JITTER_INSTRUCTION_PROLOG_(primitive-cdr/fR, primitive_mcdr__fR, hot)
25178   {
25179     /* This specialized instruction is not a replacement. */
25180 #   undef JITTER_BRANCH_FAST
25181 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25182 #   undef JITTER_BRANCH_FAST_IF_ZERO
25183 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25184 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25185 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25186 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25187 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25188 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25189 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25190 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25191 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25192 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25193 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25194 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25195 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25196 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25197 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25198 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25199 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25200 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25201 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25202 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25203 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25204 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25205 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25206 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25207 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25208 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25209 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25210 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25211 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25212 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25213 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25214 #   undef JITTER_BRANCH_FAST_IF_AND
25215 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25216 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25217 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25218 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25219 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25220 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25221 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25222 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25223 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25224 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25225 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25226 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25227 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25228 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25229 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25230 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25231 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25232 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25233 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25234 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25235 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25236 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25237 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25238 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25239 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25240 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25241 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25242 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25243 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25244 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       128
25245 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-cdr/fR
25246 
25247 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcdr__fR
25248 
25249   /* The residual arity varies depending on whether we have fast labels. */
25250 #ifdef JITTER_HAVE_PATCH_IN
25251   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25252 #else
25253   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
25254 #endif // #ifdef JITTER_HAVE_PATCH_IN
25255 
25256   /* Define argument-access macros for primitive-cdr/fR . */
25257 #ifdef JITTER_HAVE_PATCH_IN
25258   /* Define argument-access macros assuming that fast branches are enabled. */
25259     /* The 0th argument is a "residual" fast label.  Define its
25260        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
25261        so that at replication time we know what instruction address to patch in. */
25262 #   define JITTER_ARGF0 0
25263     /* JITTER_ARG0 is intentionally not defined for a fast label. */
25264 
25265 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
25266 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
25267 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
25268 
25269 #else
25270   /* Define argument-access macros assuming that fast branches are disabled. */
25271 #if defined(JITTER_DISPATCH_NO_THREADING)
25272 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
25273     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
25274 #elif defined (JITTER_REPLICATE)
25275 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
25276 #else
25277 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
25278 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
25279 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
25280 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
25281 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
25282 #   define JITTER_ARGF0 JITTER_ARGP0
25283 
25284 # endif // #ifdef JITTER_HAVE_PATCH_IN
25285 
25286 #if defined (JITTER_PROFILE_SAMPLE)
25287   JITTER_PROFILE_SAMPLE_UPDATE
25288      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25289       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25290   /* Force the compiler not move sample-profiling instrumentation
25291      beyond this point; this way the actual user code is timed.
25292      This is still not perfect, as residuals are materialised before
25293      we arrive here, but should be adequate at least for slow VM
25294      instructions. */
25295   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25296 #endif
25297 #if defined (JITTER_PROFILE_COUNT)
25298   /* Notice that, differently from the code above, this
25299      instrumentation code *can* be reordered freely: as long as a
25300      VM instruction is counted, the count increment can be placed
25301      anyehere.  Let GCC move this code and possibly achieve better
25302      throughput by exploiting instruction-level parallelism and
25303      therefore approximate more closely a non-profiled build. */
25304   JITTER_PROFILE_COUNT_UPDATE
25305      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25306       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25307 #endif
25308 
25309 /* User-specified code, instruction-beginning-c part: beginning. */
25310 
25311 
25312 /* User-specified code, instruction-beginning-c part: end */
25313 
25314 
25315     /* User code for primitive-cdr/fR . */
25316 
25317     JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
25318     JITTERLISP_CDR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
25319 
25320     /* End of the user code for primitive-cdr/fR . */
25321 
25322 /* User-specified code, instruction-end-c part: beginning. */
25323 
25324 
25325 /* User-specified code, instruction-end-c part: end */
25326 
25327     /* Undefine the primitive-cdr/fR argument macros so they can't be used
25328        by mistake in the instruction body coming next. */
25329 #   undef JITTER_SLOW_REGISTER_OFFSET0
25330 #   undef JITTER_ARG0
25331 #   undef JITTER_ARGN0
25332 #   undef JITTER_ARGU0
25333 #   undef JITTER_ARGP0
25334 #   undef JITTER_ARGF0
25335 
25336 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25337 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25338 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25339 
25340   }
25341  JITTER_INSTRUCTION_EPILOG_(primitive-cdr/fR, primitive_mcdr__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25342 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25343 
25344   JITTER_INSTRUCTION_PROLOG_(primitive-characterp, primitive_mcharacterp, hot)
25345   {
25346     /* This specialized instruction is not a replacement. */
25347 #   undef JITTER_BRANCH_FAST
25348 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25349 #   undef JITTER_BRANCH_FAST_IF_ZERO
25350 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25351 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25352 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25353 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25354 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25355 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25356 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25357 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25358 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25359 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25360 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25361 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25362 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25363 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25364 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25365 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25366 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25367 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25368 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25369 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25370 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25371 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25372 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25373 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25374 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25375 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25376 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25377 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25378 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25379 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25380 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25381 #   undef JITTER_BRANCH_FAST_IF_AND
25382 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25383 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25384 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25385 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25386 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25387 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25388 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25389 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25390 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25391 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25392 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25393 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25394 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25395 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25396 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25397 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25398 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25399 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25400 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25401 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25402 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25403 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25404 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25405 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25406 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25407 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25408 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25409 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25410 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25411 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       129
25412 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-characterp
25413 
25414 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcharacterp
25415 
25416   /* The residual arity for this instruction does not depend on fast labels. */
25417   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25418 
25419 
25420 #if defined (JITTER_PROFILE_SAMPLE)
25421   JITTER_PROFILE_SAMPLE_UPDATE
25422      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25423       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25424   /* Force the compiler not move sample-profiling instrumentation
25425      beyond this point; this way the actual user code is timed.
25426      This is still not perfect, as residuals are materialised before
25427      we arrive here, but should be adequate at least for slow VM
25428      instructions. */
25429   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25430 #endif
25431 #if defined (JITTER_PROFILE_COUNT)
25432   /* Notice that, differently from the code above, this
25433      instrumentation code *can* be reordered freely: as long as a
25434      VM instruction is counted, the count increment can be placed
25435      anyehere.  Let GCC move this code and possibly achieve better
25436      throughput by exploiting instruction-level parallelism and
25437      therefore approximate more closely a non-profiled build. */
25438   JITTER_PROFILE_COUNT_UPDATE
25439      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25440       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25441 #endif
25442 
25443 /* User-specified code, instruction-beginning-c part: beginning. */
25444 
25445 
25446 /* User-specified code, instruction-beginning-c part: end */
25447 
25448 
25449     /* User code for primitive-characterp . */
25450 
25451     JITTERLISP_CHARACTERP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
25452 
25453     /* End of the user code for primitive-characterp . */
25454 
25455 /* User-specified code, instruction-end-c part: beginning. */
25456 
25457 
25458 /* User-specified code, instruction-end-c part: end */
25459 
25460     /* Undefine the primitive-characterp argument macros so they can't be used
25461        by mistake in the instruction body coming next. */
25462 
25463 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25464 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25465 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25466 
25467   }
25468  JITTER_INSTRUCTION_EPILOG_(primitive-characterp, primitive_mcharacterp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25469 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25470 
25471   JITTER_INSTRUCTION_PROLOG_(primitive-cons-special, primitive_mcons_mspecial, hot)
25472   {
25473     /* This specialized instruction is not a replacement. */
25474 #   undef JITTER_BRANCH_FAST
25475 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25476 #   undef JITTER_BRANCH_FAST_IF_ZERO
25477 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25478 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25479 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25480 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25481 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25482 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25483 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25484 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25485 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25486 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25487 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25488 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25489 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25490 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25491 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25492 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25493 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25494 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25495 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25496 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25497 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25498 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25499 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25500 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25501 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25502 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25503 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25504 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25505 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25506 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25507 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25508 #   undef JITTER_BRANCH_FAST_IF_AND
25509 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25510 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25511 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25512 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25513 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25514 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25515 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25516 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25517 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25518 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25519 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25520 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25521 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25522 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25523 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25524 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25525 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25526 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25527 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25528 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25529 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25530 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25531 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25532 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25533 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25534 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25535 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25536 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25537 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25538 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       130
25539 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-cons-special
25540 
25541 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mcons_mspecial
25542 
25543   /* The residual arity for this instruction does not depend on fast labels. */
25544   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25545 
25546 
25547 #if defined (JITTER_PROFILE_SAMPLE)
25548   JITTER_PROFILE_SAMPLE_UPDATE
25549      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25550       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25551   /* Force the compiler not move sample-profiling instrumentation
25552      beyond this point; this way the actual user code is timed.
25553      This is still not perfect, as residuals are materialised before
25554      we arrive here, but should be adequate at least for slow VM
25555      instructions. */
25556   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25557 #endif
25558 #if defined (JITTER_PROFILE_COUNT)
25559   /* Notice that, differently from the code above, this
25560      instrumentation code *can* be reordered freely: as long as a
25561      VM instruction is counted, the count increment can be placed
25562      anyehere.  Let GCC move this code and possibly achieve better
25563      throughput by exploiting instruction-level parallelism and
25564      therefore approximate more closely a non-profiled build. */
25565   JITTER_PROFILE_COUNT_UPDATE
25566      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25567       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25568 #endif
25569 
25570 /* User-specified code, instruction-beginning-c part: beginning. */
25571 
25572 
25573 /* User-specified code, instruction-beginning-c part: end */
25574 
25575 
25576     /* User code for primitive-cons-special . */
25577 
25578 #ifdef JITTER_GC_STUB
25579     /* This is a preliminary version of the allocation fast path, using a
25580        still non-existing Jitter garbage collector.
25581        Of course most of this should be factored into a macro. */
25582     const size_t allocation_size
25583       = JITTER_BYTES_PER_WORD * 2;
25584     const size_t header_size = 0;
25585     jitterlisp_object tagged_cons
25586       = JITTERLISP_CONS_ENCODE
25587           (JITTER_STATE_RUNTIME_FIELD (allocation_next)
25588            - allocation_size + header_size);
25589     JITTERLISP_CONS_DECODE (tagged_cons)->car = JITTER_UNDER_TOP_MAINSTACK();
25590     JITTERLISP_CONS_DECODE (tagged_cons)->cdr = JITTER_TOP_MAINSTACK();
25591     JITTER_TOP_MAINSTACK() = tagged_cons;
25592 #else // ! JITTER_GC_STUB
25593     JITTERLISP_CONS_(JITTER_TOP_MAINSTACK(),
25594                      JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
25595 #endif //#ifdef JITTER_GC_STUB
25596 
25597     /* End of the user code for primitive-cons-special . */
25598 
25599 /* User-specified code, instruction-end-c part: beginning. */
25600 
25601 
25602 /* User-specified code, instruction-end-c part: end */
25603 
25604     /* Undefine the primitive-cons-special argument macros so they can't be used
25605        by mistake in the instruction body coming next. */
25606 
25607 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25608 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25609 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25610 
25611   }
25612  JITTER_INSTRUCTION_EPILOG_(primitive-cons-special, primitive_mcons_mspecial, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25613 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25614 
25615   JITTER_INSTRUCTION_PROLOG_(primitive-consp, primitive_mconsp, hot)
25616   {
25617     /* This specialized instruction is not a replacement. */
25618 #   undef JITTER_BRANCH_FAST
25619 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25620 #   undef JITTER_BRANCH_FAST_IF_ZERO
25621 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25622 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25623 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25624 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25625 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25626 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25627 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25628 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25629 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25630 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25631 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25632 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25633 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25634 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25635 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25636 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25637 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25638 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25639 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25640 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25641 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25642 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25643 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25644 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25645 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25646 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25647 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25648 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25649 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25650 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25651 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25652 #   undef JITTER_BRANCH_FAST_IF_AND
25653 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25654 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25655 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25656 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25657 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25658 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25659 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25660 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25661 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25662 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25663 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25664 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25665 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25666 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25667 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25668 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25669 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25670 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25671 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25672 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25673 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25674 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25675 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25676 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25677 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25678 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25679 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25680 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25681 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25682 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       131
25683 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-consp
25684 
25685 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mconsp
25686 
25687   /* The residual arity for this instruction does not depend on fast labels. */
25688   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25689 
25690 
25691 #if defined (JITTER_PROFILE_SAMPLE)
25692   JITTER_PROFILE_SAMPLE_UPDATE
25693      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25694       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25695   /* Force the compiler not move sample-profiling instrumentation
25696      beyond this point; this way the actual user code is timed.
25697      This is still not perfect, as residuals are materialised before
25698      we arrive here, but should be adequate at least for slow VM
25699      instructions. */
25700   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25701 #endif
25702 #if defined (JITTER_PROFILE_COUNT)
25703   /* Notice that, differently from the code above, this
25704      instrumentation code *can* be reordered freely: as long as a
25705      VM instruction is counted, the count increment can be placed
25706      anyehere.  Let GCC move this code and possibly achieve better
25707      throughput by exploiting instruction-level parallelism and
25708      therefore approximate more closely a non-profiled build. */
25709   JITTER_PROFILE_COUNT_UPDATE
25710      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25711       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25712 #endif
25713 
25714 /* User-specified code, instruction-beginning-c part: beginning. */
25715 
25716 
25717 /* User-specified code, instruction-beginning-c part: end */
25718 
25719 
25720     /* User code for primitive-consp . */
25721 
25722     JITTERLISP_CONSP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
25723 
25724     /* End of the user code for primitive-consp . */
25725 
25726 /* User-specified code, instruction-end-c part: beginning. */
25727 
25728 
25729 /* User-specified code, instruction-end-c part: end */
25730 
25731     /* Undefine the primitive-consp argument macros so they can't be used
25732        by mistake in the instruction body coming next. */
25733 
25734 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25735 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25736 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25737 
25738   }
25739  JITTER_INSTRUCTION_EPILOG_(primitive-consp, primitive_mconsp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25740 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25741 
25742   JITTER_INSTRUCTION_PROLOG_(primitive-eqp, primitive_meqp, hot)
25743   {
25744     /* This specialized instruction is not a replacement. */
25745 #   undef JITTER_BRANCH_FAST
25746 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25747 #   undef JITTER_BRANCH_FAST_IF_ZERO
25748 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25749 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25750 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25751 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25752 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25753 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25754 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25755 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25756 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25757 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25758 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25759 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25760 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25761 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25762 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25763 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25764 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25765 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25766 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25767 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25768 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25769 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25770 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25771 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25772 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25773 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25774 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25775 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25776 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25777 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25778 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25779 #   undef JITTER_BRANCH_FAST_IF_AND
25780 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25781 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25782 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25783 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25784 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25785 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25786 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25787 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25788 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25789 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25790 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25791 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25792 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25793 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25794 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25795 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25796 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25797 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25798 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25799 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25800 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25801 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25802 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25803 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25804 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25805 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25806 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25807 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25808 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25809 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       132
25810 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-eqp
25811 
25812 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_meqp
25813 
25814   /* The residual arity for this instruction does not depend on fast labels. */
25815   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25816 
25817 
25818 #if defined (JITTER_PROFILE_SAMPLE)
25819   JITTER_PROFILE_SAMPLE_UPDATE
25820      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25821       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25822   /* Force the compiler not move sample-profiling instrumentation
25823      beyond this point; this way the actual user code is timed.
25824      This is still not perfect, as residuals are materialised before
25825      we arrive here, but should be adequate at least for slow VM
25826      instructions. */
25827   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25828 #endif
25829 #if defined (JITTER_PROFILE_COUNT)
25830   /* Notice that, differently from the code above, this
25831      instrumentation code *can* be reordered freely: as long as a
25832      VM instruction is counted, the count increment can be placed
25833      anyehere.  Let GCC move this code and possibly achieve better
25834      throughput by exploiting instruction-level parallelism and
25835      therefore approximate more closely a non-profiled build. */
25836   JITTER_PROFILE_COUNT_UPDATE
25837      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25838       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25839 #endif
25840 
25841 /* User-specified code, instruction-beginning-c part: beginning. */
25842 
25843 
25844 /* User-specified code, instruction-beginning-c part: end */
25845 
25846 
25847     /* User code for primitive-eqp . */
25848 
25849     JITTERLISP_EQP_(JITTER_TOP_MAINSTACK(),
25850                     JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
25851     JITTER_NIP_MAINSTACK();
25852 
25853     /* End of the user code for primitive-eqp . */
25854 
25855 /* User-specified code, instruction-end-c part: beginning. */
25856 
25857 
25858 /* User-specified code, instruction-end-c part: end */
25859 
25860     /* Undefine the primitive-eqp argument macros so they can't be used
25861        by mistake in the instruction body coming next. */
25862 
25863 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
25864 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
25865 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
25866 
25867   }
25868  JITTER_INSTRUCTION_EPILOG_(primitive-eqp, primitive_meqp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
25869 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
25870 
25871   JITTER_INSTRUCTION_PROLOG_(primitive-fixnum-eqp/fR, primitive_mfixnum_meqp__fR, hot)
25872   {
25873     /* This specialized instruction is not a replacement. */
25874 #   undef JITTER_BRANCH_FAST
25875 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
25876 #   undef JITTER_BRANCH_FAST_IF_ZERO
25877 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
25878 #   undef JITTER_BRANCH_FAST_IF_NONZERO
25879 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
25880 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
25881 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
25882 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
25883 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
25884 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
25885 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
25886 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
25887 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
25888 #   undef JITTER_BRANCH_FAST_IF_EQUAL
25889 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
25890 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
25891 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
25892 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
25893 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
25894 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25895 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
25896 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25897 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
25898 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25899 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
25900 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25901 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
25902 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25903 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
25904 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25905 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
25906 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25907 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
25908 #   undef JITTER_BRANCH_FAST_IF_AND
25909 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
25910 #   undef JITTER_BRANCH_FAST_IF_NOTAND
25911 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
25912 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25913 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
25914 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25915 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
25916 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25917 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
25918 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25919 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
25920 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25921 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
25922 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25923 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
25924 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25925 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
25926 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25927 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
25928 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25929 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
25930 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25931 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
25932 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25933 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
25934 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25935 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
25936 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25937 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
25938 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       133
25939 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-fixnum-eqp/fR
25940 
25941 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mfixnum_meqp__fR
25942 
25943   /* The residual arity varies depending on whether we have fast labels. */
25944 #ifdef JITTER_HAVE_PATCH_IN
25945   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
25946 #else
25947   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
25948 #endif // #ifdef JITTER_HAVE_PATCH_IN
25949 
25950   /* Define argument-access macros for primitive-fixnum-eqp/fR . */
25951 #ifdef JITTER_HAVE_PATCH_IN
25952   /* Define argument-access macros assuming that fast branches are enabled. */
25953     /* The 0th argument is a "residual" fast label.  Define its
25954        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
25955        so that at replication time we know what instruction address to patch in. */
25956 #   define JITTER_ARGF0 0
25957     /* JITTER_ARG0 is intentionally not defined for a fast label. */
25958 
25959 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
25960 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
25961 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
25962 
25963 #else
25964   /* Define argument-access macros assuming that fast branches are disabled. */
25965 #if defined(JITTER_DISPATCH_NO_THREADING)
25966 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
25967     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
25968 #elif defined (JITTER_REPLICATE)
25969 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
25970 #else
25971 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
25972 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
25973 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
25974 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
25975 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
25976 #   define JITTER_ARGF0 JITTER_ARGP0
25977 
25978 # endif // #ifdef JITTER_HAVE_PATCH_IN
25979 
25980 #if defined (JITTER_PROFILE_SAMPLE)
25981   JITTER_PROFILE_SAMPLE_UPDATE
25982      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
25983       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
25984   /* Force the compiler not move sample-profiling instrumentation
25985      beyond this point; this way the actual user code is timed.
25986      This is still not perfect, as residuals are materialised before
25987      we arrive here, but should be adequate at least for slow VM
25988      instructions. */
25989   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
25990 #endif
25991 #if defined (JITTER_PROFILE_COUNT)
25992   /* Notice that, differently from the code above, this
25993      instrumentation code *can* be reordered freely: as long as a
25994      VM instruction is counted, the count increment can be placed
25995      anyehere.  Let GCC move this code and possibly achieve better
25996      throughput by exploiting instruction-level parallelism and
25997      therefore approximate more closely a non-profiled build. */
25998   JITTER_PROFILE_COUNT_UPDATE
25999      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26000       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26001 #endif
26002 
26003 /* User-specified code, instruction-beginning-c part: beginning. */
26004 
26005 
26006 /* User-specified code, instruction-beginning-c part: end */
26007 
26008 
26009     /* User code for primitive-fixnum-eqp/fR . */
26010 
26011     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
26012     JITTERLISP_EQP_(JITTER_TOP_MAINSTACK(),
26013                     JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
26014     JITTER_NIP_MAINSTACK();
26015 
26016     /* End of the user code for primitive-fixnum-eqp/fR . */
26017 
26018 /* User-specified code, instruction-end-c part: beginning. */
26019 
26020 
26021 /* User-specified code, instruction-end-c part: end */
26022 
26023     /* Undefine the primitive-fixnum-eqp/fR argument macros so they can't be used
26024        by mistake in the instruction body coming next. */
26025 #   undef JITTER_SLOW_REGISTER_OFFSET0
26026 #   undef JITTER_ARG0
26027 #   undef JITTER_ARGN0
26028 #   undef JITTER_ARGU0
26029 #   undef JITTER_ARGP0
26030 #   undef JITTER_ARGF0
26031 
26032 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26033 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26034 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26035 
26036   }
26037  JITTER_INSTRUCTION_EPILOG_(primitive-fixnum-eqp/fR, primitive_mfixnum_meqp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26038 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26039 
26040   JITTER_INSTRUCTION_PROLOG_(primitive-fixnum-not-eqp/fR, primitive_mfixnum_mnot_meqp__fR, hot)
26041   {
26042     /* This specialized instruction is not a replacement. */
26043 #   undef JITTER_BRANCH_FAST
26044 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26045 #   undef JITTER_BRANCH_FAST_IF_ZERO
26046 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26047 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26048 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26049 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26050 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26051 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26052 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26053 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26054 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26055 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26056 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26057 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26058 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26059 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26060 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26061 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26062 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26063 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26064 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26065 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26066 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26067 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26068 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26069 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26070 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26071 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26072 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26073 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26074 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26075 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26076 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26077 #   undef JITTER_BRANCH_FAST_IF_AND
26078 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26079 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26080 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26081 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26082 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26083 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26084 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26085 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26086 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26087 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26088 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26089 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26090 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26091 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26092 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26093 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26094 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26095 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26096 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26097 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26098 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26099 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26100 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26101 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26102 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26103 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26104 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26105 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26106 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26107 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       134
26108 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-fixnum-not-eqp/fR
26109 
26110 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mfixnum_mnot_meqp__fR
26111 
26112   /* The residual arity varies depending on whether we have fast labels. */
26113 #ifdef JITTER_HAVE_PATCH_IN
26114   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26115 #else
26116   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
26117 #endif // #ifdef JITTER_HAVE_PATCH_IN
26118 
26119   /* Define argument-access macros for primitive-fixnum-not-eqp/fR . */
26120 #ifdef JITTER_HAVE_PATCH_IN
26121   /* Define argument-access macros assuming that fast branches are enabled. */
26122     /* The 0th argument is a "residual" fast label.  Define its
26123        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
26124        so that at replication time we know what instruction address to patch in. */
26125 #   define JITTER_ARGF0 0
26126     /* JITTER_ARG0 is intentionally not defined for a fast label. */
26127 
26128 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26129 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26130 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26131 
26132 #else
26133   /* Define argument-access macros assuming that fast branches are disabled. */
26134 #if defined(JITTER_DISPATCH_NO_THREADING)
26135 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
26136     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
26137 #elif defined (JITTER_REPLICATE)
26138 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
26139 #else
26140 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
26141 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
26142 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26143 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26144 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26145 #   define JITTER_ARGF0 JITTER_ARGP0
26146 
26147 # endif // #ifdef JITTER_HAVE_PATCH_IN
26148 
26149 #if defined (JITTER_PROFILE_SAMPLE)
26150   JITTER_PROFILE_SAMPLE_UPDATE
26151      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26152       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26153   /* Force the compiler not move sample-profiling instrumentation
26154      beyond this point; this way the actual user code is timed.
26155      This is still not perfect, as residuals are materialised before
26156      we arrive here, but should be adequate at least for slow VM
26157      instructions. */
26158   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26159 #endif
26160 #if defined (JITTER_PROFILE_COUNT)
26161   /* Notice that, differently from the code above, this
26162      instrumentation code *can* be reordered freely: as long as a
26163      VM instruction is counted, the count increment can be placed
26164      anyehere.  Let GCC move this code and possibly achieve better
26165      throughput by exploiting instruction-level parallelism and
26166      therefore approximate more closely a non-profiled build. */
26167   JITTER_PROFILE_COUNT_UPDATE
26168      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26169       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26170 #endif
26171 
26172 /* User-specified code, instruction-beginning-c part: beginning. */
26173 
26174 
26175 /* User-specified code, instruction-beginning-c part: end */
26176 
26177 
26178     /* User code for primitive-fixnum-not-eqp/fR . */
26179 
26180     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
26181     JITTERLISP_NOT_EQP_(JITTER_TOP_MAINSTACK(),
26182                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
26183     JITTER_NIP_MAINSTACK();
26184 
26185     /* End of the user code for primitive-fixnum-not-eqp/fR . */
26186 
26187 /* User-specified code, instruction-end-c part: beginning. */
26188 
26189 
26190 /* User-specified code, instruction-end-c part: end */
26191 
26192     /* Undefine the primitive-fixnum-not-eqp/fR argument macros so they can't be used
26193        by mistake in the instruction body coming next. */
26194 #   undef JITTER_SLOW_REGISTER_OFFSET0
26195 #   undef JITTER_ARG0
26196 #   undef JITTER_ARGN0
26197 #   undef JITTER_ARGU0
26198 #   undef JITTER_ARGP0
26199 #   undef JITTER_ARGF0
26200 
26201 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26202 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26203 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26204 
26205   }
26206  JITTER_INSTRUCTION_EPILOG_(primitive-fixnum-not-eqp/fR, primitive_mfixnum_mnot_meqp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26207 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26208 
26209   JITTER_INSTRUCTION_PROLOG_(primitive-fixnump, primitive_mfixnump, hot)
26210   {
26211     /* This specialized instruction is not a replacement. */
26212 #   undef JITTER_BRANCH_FAST
26213 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26214 #   undef JITTER_BRANCH_FAST_IF_ZERO
26215 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26216 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26217 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26218 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26219 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26220 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26221 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26222 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26223 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26224 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26225 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26226 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26227 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26228 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26229 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26230 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26231 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26232 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26233 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26234 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26235 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26236 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26237 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26238 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26239 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26240 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26241 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26242 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26243 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26244 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26245 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26246 #   undef JITTER_BRANCH_FAST_IF_AND
26247 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26248 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26249 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26250 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26251 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26252 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26253 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26254 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26255 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26256 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26257 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26258 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26259 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26260 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26261 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26262 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26263 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26264 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26265 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26266 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26267 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26268 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26269 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26270 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26271 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26272 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26273 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26274 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26275 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26276 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       135
26277 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-fixnump
26278 
26279 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mfixnump
26280 
26281   /* The residual arity for this instruction does not depend on fast labels. */
26282   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26283 
26284 
26285 #if defined (JITTER_PROFILE_SAMPLE)
26286   JITTER_PROFILE_SAMPLE_UPDATE
26287      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26288       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26289   /* Force the compiler not move sample-profiling instrumentation
26290      beyond this point; this way the actual user code is timed.
26291      This is still not perfect, as residuals are materialised before
26292      we arrive here, but should be adequate at least for slow VM
26293      instructions. */
26294   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26295 #endif
26296 #if defined (JITTER_PROFILE_COUNT)
26297   /* Notice that, differently from the code above, this
26298      instrumentation code *can* be reordered freely: as long as a
26299      VM instruction is counted, the count increment can be placed
26300      anyehere.  Let GCC move this code and possibly achieve better
26301      throughput by exploiting instruction-level parallelism and
26302      therefore approximate more closely a non-profiled build. */
26303   JITTER_PROFILE_COUNT_UPDATE
26304      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26305       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26306 #endif
26307 
26308 /* User-specified code, instruction-beginning-c part: beginning. */
26309 
26310 
26311 /* User-specified code, instruction-beginning-c part: end */
26312 
26313 
26314     /* User code for primitive-fixnump . */
26315 
26316     JITTERLISP_FIXNUMP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
26317 
26318     /* End of the user code for primitive-fixnump . */
26319 
26320 /* User-specified code, instruction-end-c part: beginning. */
26321 
26322 
26323 /* User-specified code, instruction-end-c part: end */
26324 
26325     /* Undefine the primitive-fixnump argument macros so they can't be used
26326        by mistake in the instruction body coming next. */
26327 
26328 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26329 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26330 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26331 
26332   }
26333  JITTER_INSTRUCTION_EPILOG_(primitive-fixnump, primitive_mfixnump, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26334 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26335 
26336   JITTER_INSTRUCTION_PROLOG_(primitive-greaterp/fR, primitive_mgreaterp__fR, hot)
26337   {
26338     /* This specialized instruction is not a replacement. */
26339 #   undef JITTER_BRANCH_FAST
26340 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26341 #   undef JITTER_BRANCH_FAST_IF_ZERO
26342 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26343 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26344 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26345 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26346 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26347 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26348 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26349 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26350 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26351 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26352 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26353 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26354 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26355 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26356 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26357 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26358 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26359 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26360 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26361 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26362 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26363 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26364 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26365 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26366 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26367 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26368 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26369 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26370 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26371 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26372 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26373 #   undef JITTER_BRANCH_FAST_IF_AND
26374 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26375 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26376 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26377 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26378 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26379 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26380 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26381 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26382 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26383 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26384 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26385 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26386 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26387 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26388 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26389 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26390 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26391 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26392 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26393 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26394 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26395 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26396 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26397 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26398 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26399 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26400 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26401 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26402 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26403 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       136
26404 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-greaterp/fR
26405 
26406 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mgreaterp__fR
26407 
26408   /* The residual arity varies depending on whether we have fast labels. */
26409 #ifdef JITTER_HAVE_PATCH_IN
26410   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26411 #else
26412   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
26413 #endif // #ifdef JITTER_HAVE_PATCH_IN
26414 
26415   /* Define argument-access macros for primitive-greaterp/fR . */
26416 #ifdef JITTER_HAVE_PATCH_IN
26417   /* Define argument-access macros assuming that fast branches are enabled. */
26418     /* The 0th argument is a "residual" fast label.  Define its
26419        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
26420        so that at replication time we know what instruction address to patch in. */
26421 #   define JITTER_ARGF0 0
26422     /* JITTER_ARG0 is intentionally not defined for a fast label. */
26423 
26424 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26425 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26426 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26427 
26428 #else
26429   /* Define argument-access macros assuming that fast branches are disabled. */
26430 #if defined(JITTER_DISPATCH_NO_THREADING)
26431 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
26432     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
26433 #elif defined (JITTER_REPLICATE)
26434 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
26435 #else
26436 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
26437 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
26438 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26439 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26440 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26441 #   define JITTER_ARGF0 JITTER_ARGP0
26442 
26443 # endif // #ifdef JITTER_HAVE_PATCH_IN
26444 
26445 #if defined (JITTER_PROFILE_SAMPLE)
26446   JITTER_PROFILE_SAMPLE_UPDATE
26447      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26448       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26449   /* Force the compiler not move sample-profiling instrumentation
26450      beyond this point; this way the actual user code is timed.
26451      This is still not perfect, as residuals are materialised before
26452      we arrive here, but should be adequate at least for slow VM
26453      instructions. */
26454   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26455 #endif
26456 #if defined (JITTER_PROFILE_COUNT)
26457   /* Notice that, differently from the code above, this
26458      instrumentation code *can* be reordered freely: as long as a
26459      VM instruction is counted, the count increment can be placed
26460      anyehere.  Let GCC move this code and possibly achieve better
26461      throughput by exploiting instruction-level parallelism and
26462      therefore approximate more closely a non-profiled build. */
26463   JITTER_PROFILE_COUNT_UPDATE
26464      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26465       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26466 #endif
26467 
26468 /* User-specified code, instruction-beginning-c part: beginning. */
26469 
26470 
26471 /* User-specified code, instruction-beginning-c part: end */
26472 
26473 
26474     /* User code for primitive-greaterp/fR . */
26475 
26476     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
26477     JITTERLISP_GREATERP_(JITTER_TOP_MAINSTACK(),
26478                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
26479     JITTER_NIP_MAINSTACK();
26480 
26481     /* End of the user code for primitive-greaterp/fR . */
26482 
26483 /* User-specified code, instruction-end-c part: beginning. */
26484 
26485 
26486 /* User-specified code, instruction-end-c part: end */
26487 
26488     /* Undefine the primitive-greaterp/fR argument macros so they can't be used
26489        by mistake in the instruction body coming next. */
26490 #   undef JITTER_SLOW_REGISTER_OFFSET0
26491 #   undef JITTER_ARG0
26492 #   undef JITTER_ARGN0
26493 #   undef JITTER_ARGU0
26494 #   undef JITTER_ARGP0
26495 #   undef JITTER_ARGF0
26496 
26497 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26498 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26499 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26500 
26501   }
26502  JITTER_INSTRUCTION_EPILOG_(primitive-greaterp/fR, primitive_mgreaterp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26503 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26504 
26505   JITTER_INSTRUCTION_PROLOG_(primitive-lessp/fR, primitive_mlessp__fR, hot)
26506   {
26507     /* This specialized instruction is not a replacement. */
26508 #   undef JITTER_BRANCH_FAST
26509 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26510 #   undef JITTER_BRANCH_FAST_IF_ZERO
26511 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26512 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26513 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26514 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26515 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26516 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26517 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26518 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26519 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26520 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26521 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26522 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26523 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26524 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26525 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26526 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26527 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26528 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26529 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26530 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26531 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26532 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26533 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26534 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26535 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26536 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26537 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26538 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26539 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26540 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26541 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26542 #   undef JITTER_BRANCH_FAST_IF_AND
26543 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26544 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26545 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26546 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26547 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26548 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26549 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26550 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26551 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26552 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26553 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26554 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26555 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26556 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26557 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26558 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26559 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26560 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26561 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26562 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26563 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26564 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26565 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26566 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26567 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26568 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26569 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26570 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26571 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26572 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       137
26573 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-lessp/fR
26574 
26575 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mlessp__fR
26576 
26577   /* The residual arity varies depending on whether we have fast labels. */
26578 #ifdef JITTER_HAVE_PATCH_IN
26579   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26580 #else
26581   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
26582 #endif // #ifdef JITTER_HAVE_PATCH_IN
26583 
26584   /* Define argument-access macros for primitive-lessp/fR . */
26585 #ifdef JITTER_HAVE_PATCH_IN
26586   /* Define argument-access macros assuming that fast branches are enabled. */
26587     /* The 0th argument is a "residual" fast label.  Define its
26588        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
26589        so that at replication time we know what instruction address to patch in. */
26590 #   define JITTER_ARGF0 0
26591     /* JITTER_ARG0 is intentionally not defined for a fast label. */
26592 
26593 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26594 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26595 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26596 
26597 #else
26598   /* Define argument-access macros assuming that fast branches are disabled. */
26599 #if defined(JITTER_DISPATCH_NO_THREADING)
26600 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
26601     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
26602 #elif defined (JITTER_REPLICATE)
26603 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
26604 #else
26605 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
26606 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
26607 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26608 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26609 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26610 #   define JITTER_ARGF0 JITTER_ARGP0
26611 
26612 # endif // #ifdef JITTER_HAVE_PATCH_IN
26613 
26614 #if defined (JITTER_PROFILE_SAMPLE)
26615   JITTER_PROFILE_SAMPLE_UPDATE
26616      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26617       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26618   /* Force the compiler not move sample-profiling instrumentation
26619      beyond this point; this way the actual user code is timed.
26620      This is still not perfect, as residuals are materialised before
26621      we arrive here, but should be adequate at least for slow VM
26622      instructions. */
26623   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26624 #endif
26625 #if defined (JITTER_PROFILE_COUNT)
26626   /* Notice that, differently from the code above, this
26627      instrumentation code *can* be reordered freely: as long as a
26628      VM instruction is counted, the count increment can be placed
26629      anyehere.  Let GCC move this code and possibly achieve better
26630      throughput by exploiting instruction-level parallelism and
26631      therefore approximate more closely a non-profiled build. */
26632   JITTER_PROFILE_COUNT_UPDATE
26633      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26634       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26635 #endif
26636 
26637 /* User-specified code, instruction-beginning-c part: beginning. */
26638 
26639 
26640 /* User-specified code, instruction-beginning-c part: end */
26641 
26642 
26643     /* User code for primitive-lessp/fR . */
26644 
26645     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
26646     JITTERLISP_LESSP_(JITTER_TOP_MAINSTACK(),
26647                       JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
26648     JITTER_NIP_MAINSTACK();
26649 
26650     /* End of the user code for primitive-lessp/fR . */
26651 
26652 /* User-specified code, instruction-end-c part: beginning. */
26653 
26654 
26655 /* User-specified code, instruction-end-c part: end */
26656 
26657     /* Undefine the primitive-lessp/fR argument macros so they can't be used
26658        by mistake in the instruction body coming next. */
26659 #   undef JITTER_SLOW_REGISTER_OFFSET0
26660 #   undef JITTER_ARG0
26661 #   undef JITTER_ARGN0
26662 #   undef JITTER_ARGU0
26663 #   undef JITTER_ARGP0
26664 #   undef JITTER_ARGF0
26665 
26666 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26667 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26668 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26669 
26670   }
26671  JITTER_INSTRUCTION_EPILOG_(primitive-lessp/fR, primitive_mlessp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26672 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26673 
26674   JITTER_INSTRUCTION_PROLOG_(primitive-negate/fR, primitive_mnegate__fR, hot)
26675   {
26676     /* This specialized instruction is not a replacement. */
26677 #   undef JITTER_BRANCH_FAST
26678 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26679 #   undef JITTER_BRANCH_FAST_IF_ZERO
26680 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26681 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26682 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26683 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26684 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26685 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26686 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26687 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26688 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26689 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26690 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26691 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26692 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26693 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26694 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26695 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26696 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26697 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26698 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26699 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26700 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26701 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26702 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26703 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26704 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26705 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26706 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26707 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26708 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26709 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26710 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26711 #   undef JITTER_BRANCH_FAST_IF_AND
26712 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26713 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26714 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26715 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26716 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26717 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26718 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26719 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26720 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26721 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26722 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26723 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26724 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26725 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26726 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26727 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26728 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26729 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26730 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26731 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26732 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26733 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26734 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26735 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26736 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26737 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26738 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26739 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26740 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26741 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       138
26742 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-negate/fR
26743 
26744 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnegate__fR
26745 
26746   /* The residual arity varies depending on whether we have fast labels. */
26747 #ifdef JITTER_HAVE_PATCH_IN
26748   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26749 #else
26750   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
26751 #endif // #ifdef JITTER_HAVE_PATCH_IN
26752 
26753   /* Define argument-access macros for primitive-negate/fR . */
26754 #ifdef JITTER_HAVE_PATCH_IN
26755   /* Define argument-access macros assuming that fast branches are enabled. */
26756     /* The 0th argument is a "residual" fast label.  Define its
26757        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
26758        so that at replication time we know what instruction address to patch in. */
26759 #   define JITTER_ARGF0 0
26760     /* JITTER_ARG0 is intentionally not defined for a fast label. */
26761 
26762 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26763 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26764 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26765 
26766 #else
26767   /* Define argument-access macros assuming that fast branches are disabled. */
26768 #if defined(JITTER_DISPATCH_NO_THREADING)
26769 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
26770     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
26771 #elif defined (JITTER_REPLICATE)
26772 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
26773 #else
26774 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
26775 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
26776 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26777 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26778 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26779 #   define JITTER_ARGF0 JITTER_ARGP0
26780 
26781 # endif // #ifdef JITTER_HAVE_PATCH_IN
26782 
26783 #if defined (JITTER_PROFILE_SAMPLE)
26784   JITTER_PROFILE_SAMPLE_UPDATE
26785      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26786       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26787   /* Force the compiler not move sample-profiling instrumentation
26788      beyond this point; this way the actual user code is timed.
26789      This is still not perfect, as residuals are materialised before
26790      we arrive here, but should be adequate at least for slow VM
26791      instructions. */
26792   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26793 #endif
26794 #if defined (JITTER_PROFILE_COUNT)
26795   /* Notice that, differently from the code above, this
26796      instrumentation code *can* be reordered freely: as long as a
26797      VM instruction is counted, the count increment can be placed
26798      anyehere.  Let GCC move this code and possibly achieve better
26799      throughput by exploiting instruction-level parallelism and
26800      therefore approximate more closely a non-profiled build. */
26801   JITTER_PROFILE_COUNT_UPDATE
26802      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26803       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26804 #endif
26805 
26806 /* User-specified code, instruction-beginning-c part: beginning. */
26807 
26808 
26809 /* User-specified code, instruction-beginning-c part: end */
26810 
26811 
26812     /* User code for primitive-negate/fR . */
26813 
26814     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
26815     JITTERLISP_NEGATE_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
26816                                    JITTER_TOP_MAINSTACK(),
26817                                    JITTER_ARGF0);
26818 
26819     /* End of the user code for primitive-negate/fR . */
26820 
26821 /* User-specified code, instruction-end-c part: beginning. */
26822 
26823 
26824 /* User-specified code, instruction-end-c part: end */
26825 
26826     /* Undefine the primitive-negate/fR argument macros so they can't be used
26827        by mistake in the instruction body coming next. */
26828 #   undef JITTER_SLOW_REGISTER_OFFSET0
26829 #   undef JITTER_ARG0
26830 #   undef JITTER_ARGN0
26831 #   undef JITTER_ARGU0
26832 #   undef JITTER_ARGP0
26833 #   undef JITTER_ARGF0
26834 
26835 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
26836 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
26837 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
26838 
26839   }
26840  JITTER_INSTRUCTION_EPILOG_(primitive-negate/fR, primitive_mnegate__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
26841 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
26842 
26843   JITTER_INSTRUCTION_PROLOG_(primitive-negativep/fR, primitive_mnegativep__fR, hot)
26844   {
26845     /* This specialized instruction is not a replacement. */
26846 #   undef JITTER_BRANCH_FAST
26847 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
26848 #   undef JITTER_BRANCH_FAST_IF_ZERO
26849 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
26850 #   undef JITTER_BRANCH_FAST_IF_NONZERO
26851 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
26852 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
26853 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
26854 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
26855 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
26856 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
26857 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
26858 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
26859 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
26860 #   undef JITTER_BRANCH_FAST_IF_EQUAL
26861 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
26862 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
26863 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
26864 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
26865 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
26866 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26867 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
26868 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26869 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
26870 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26871 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
26872 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26873 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
26874 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26875 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
26876 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26877 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
26878 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26879 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
26880 #   undef JITTER_BRANCH_FAST_IF_AND
26881 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
26882 #   undef JITTER_BRANCH_FAST_IF_NOTAND
26883 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
26884 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26885 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
26886 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26887 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
26888 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26889 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
26890 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26891 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
26892 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26893 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
26894 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26895 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
26896 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26897 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
26898 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26899 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
26900 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26901 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
26902 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26903 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
26904 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26905 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
26906 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26907 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
26908 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26909 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
26910 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       139
26911 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-negativep/fR
26912 
26913 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnegativep__fR
26914 
26915   /* The residual arity varies depending on whether we have fast labels. */
26916 #ifdef JITTER_HAVE_PATCH_IN
26917   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
26918 #else
26919   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
26920 #endif // #ifdef JITTER_HAVE_PATCH_IN
26921 
26922   /* Define argument-access macros for primitive-negativep/fR . */
26923 #ifdef JITTER_HAVE_PATCH_IN
26924   /* Define argument-access macros assuming that fast branches are enabled. */
26925     /* The 0th argument is a "residual" fast label.  Define its
26926        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
26927        so that at replication time we know what instruction address to patch in. */
26928 #   define JITTER_ARGF0 0
26929     /* JITTER_ARG0 is intentionally not defined for a fast label. */
26930 
26931 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26932 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26933 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26934 
26935 #else
26936   /* Define argument-access macros assuming that fast branches are disabled. */
26937 #if defined(JITTER_DISPATCH_NO_THREADING)
26938 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
26939     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
26940 #elif defined (JITTER_REPLICATE)
26941 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
26942 #else
26943 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
26944 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
26945 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
26946 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
26947 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
26948 #   define JITTER_ARGF0 JITTER_ARGP0
26949 
26950 # endif // #ifdef JITTER_HAVE_PATCH_IN
26951 
26952 #if defined (JITTER_PROFILE_SAMPLE)
26953   JITTER_PROFILE_SAMPLE_UPDATE
26954      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26955       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26956   /* Force the compiler not move sample-profiling instrumentation
26957      beyond this point; this way the actual user code is timed.
26958      This is still not perfect, as residuals are materialised before
26959      we arrive here, but should be adequate at least for slow VM
26960      instructions. */
26961   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
26962 #endif
26963 #if defined (JITTER_PROFILE_COUNT)
26964   /* Notice that, differently from the code above, this
26965      instrumentation code *can* be reordered freely: as long as a
26966      VM instruction is counted, the count increment can be placed
26967      anyehere.  Let GCC move this code and possibly achieve better
26968      throughput by exploiting instruction-level parallelism and
26969      therefore approximate more closely a non-profiled build. */
26970   JITTER_PROFILE_COUNT_UPDATE
26971      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
26972       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
26973 #endif
26974 
26975 /* User-specified code, instruction-beginning-c part: beginning. */
26976 
26977 
26978 /* User-specified code, instruction-beginning-c part: end */
26979 
26980 
26981     /* User code for primitive-negativep/fR . */
26982 
26983     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
26984     JITTERLISP_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
26985 
26986     /* End of the user code for primitive-negativep/fR . */
26987 
26988 /* User-specified code, instruction-end-c part: beginning. */
26989 
26990 
26991 /* User-specified code, instruction-end-c part: end */
26992 
26993     /* Undefine the primitive-negativep/fR argument macros so they can't be used
26994        by mistake in the instruction body coming next. */
26995 #   undef JITTER_SLOW_REGISTER_OFFSET0
26996 #   undef JITTER_ARG0
26997 #   undef JITTER_ARGN0
26998 #   undef JITTER_ARGU0
26999 #   undef JITTER_ARGP0
27000 #   undef JITTER_ARGF0
27001 
27002 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27003 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27004 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27005 
27006   }
27007  JITTER_INSTRUCTION_EPILOG_(primitive-negativep/fR, primitive_mnegativep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27008 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27009 
27010   JITTER_INSTRUCTION_PROLOG_(primitive-non-consp, primitive_mnon_mconsp, hot)
27011   {
27012     /* This specialized instruction is not a replacement. */
27013 #   undef JITTER_BRANCH_FAST
27014 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27015 #   undef JITTER_BRANCH_FAST_IF_ZERO
27016 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27017 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27018 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27019 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27020 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27021 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27022 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27023 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27024 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27025 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27026 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27027 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27028 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27029 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27030 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27031 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27032 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27033 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27034 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27035 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27036 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27037 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27038 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27039 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27040 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27041 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27042 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27043 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27044 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27045 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27046 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27047 #   undef JITTER_BRANCH_FAST_IF_AND
27048 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27049 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27050 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27051 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27052 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27053 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27054 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27055 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27056 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27057 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27058 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27059 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27060 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27061 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27062 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27063 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27064 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27065 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27066 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27067 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27068 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27069 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27070 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27071 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27072 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27073 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27074 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27075 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27076 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27077 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       140
27078 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-consp
27079 
27080 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mconsp
27081 
27082   /* The residual arity for this instruction does not depend on fast labels. */
27083   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27084 
27085 
27086 #if defined (JITTER_PROFILE_SAMPLE)
27087   JITTER_PROFILE_SAMPLE_UPDATE
27088      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27089       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27090   /* Force the compiler not move sample-profiling instrumentation
27091      beyond this point; this way the actual user code is timed.
27092      This is still not perfect, as residuals are materialised before
27093      we arrive here, but should be adequate at least for slow VM
27094      instructions. */
27095   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27096 #endif
27097 #if defined (JITTER_PROFILE_COUNT)
27098   /* Notice that, differently from the code above, this
27099      instrumentation code *can* be reordered freely: as long as a
27100      VM instruction is counted, the count increment can be placed
27101      anyehere.  Let GCC move this code and possibly achieve better
27102      throughput by exploiting instruction-level parallelism and
27103      therefore approximate more closely a non-profiled build. */
27104   JITTER_PROFILE_COUNT_UPDATE
27105      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27106       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27107 #endif
27108 
27109 /* User-specified code, instruction-beginning-c part: beginning. */
27110 
27111 
27112 /* User-specified code, instruction-beginning-c part: end */
27113 
27114 
27115     /* User code for primitive-non-consp . */
27116 
27117     JITTERLISP_NON_CONSP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
27118 
27119     /* End of the user code for primitive-non-consp . */
27120 
27121 /* User-specified code, instruction-end-c part: beginning. */
27122 
27123 
27124 /* User-specified code, instruction-end-c part: end */
27125 
27126     /* Undefine the primitive-non-consp argument macros so they can't be used
27127        by mistake in the instruction body coming next. */
27128 
27129 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27130 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27131 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27132 
27133   }
27134  JITTER_INSTRUCTION_EPILOG_(primitive-non-consp, primitive_mnon_mconsp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27135 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27136 
27137   JITTER_INSTRUCTION_PROLOG_(primitive-non-negativep/fR, primitive_mnon_mnegativep__fR, hot)
27138   {
27139     /* This specialized instruction is not a replacement. */
27140 #   undef JITTER_BRANCH_FAST
27141 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27142 #   undef JITTER_BRANCH_FAST_IF_ZERO
27143 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27144 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27145 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27146 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27147 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27148 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27149 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27150 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27151 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27152 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27153 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27154 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27155 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27156 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27157 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27158 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27159 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27160 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27161 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27162 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27163 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27164 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27165 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27166 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27167 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27168 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27169 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27170 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27171 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27172 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27173 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27174 #   undef JITTER_BRANCH_FAST_IF_AND
27175 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27176 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27177 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27178 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27179 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27180 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27181 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27182 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27183 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27184 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27185 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27186 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27187 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27188 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27189 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27190 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27191 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27192 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27193 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27194 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27195 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27196 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27197 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27198 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27199 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27200 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27201 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27202 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27203 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27204 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       141
27205 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-negativep/fR
27206 
27207 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mnegativep__fR
27208 
27209   /* The residual arity varies depending on whether we have fast labels. */
27210 #ifdef JITTER_HAVE_PATCH_IN
27211   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27212 #else
27213   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
27214 #endif // #ifdef JITTER_HAVE_PATCH_IN
27215 
27216   /* Define argument-access macros for primitive-non-negativep/fR . */
27217 #ifdef JITTER_HAVE_PATCH_IN
27218   /* Define argument-access macros assuming that fast branches are enabled. */
27219     /* The 0th argument is a "residual" fast label.  Define its
27220        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
27221        so that at replication time we know what instruction address to patch in. */
27222 #   define JITTER_ARGF0 0
27223     /* JITTER_ARG0 is intentionally not defined for a fast label. */
27224 
27225 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27226 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27227 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27228 
27229 #else
27230   /* Define argument-access macros assuming that fast branches are disabled. */
27231 #if defined(JITTER_DISPATCH_NO_THREADING)
27232 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27233     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27234 #elif defined (JITTER_REPLICATE)
27235 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27236 #else
27237 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27238 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27239 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27240 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27241 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27242 #   define JITTER_ARGF0 JITTER_ARGP0
27243 
27244 # endif // #ifdef JITTER_HAVE_PATCH_IN
27245 
27246 #if defined (JITTER_PROFILE_SAMPLE)
27247   JITTER_PROFILE_SAMPLE_UPDATE
27248      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27249       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27250   /* Force the compiler not move sample-profiling instrumentation
27251      beyond this point; this way the actual user code is timed.
27252      This is still not perfect, as residuals are materialised before
27253      we arrive here, but should be adequate at least for slow VM
27254      instructions. */
27255   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27256 #endif
27257 #if defined (JITTER_PROFILE_COUNT)
27258   /* Notice that, differently from the code above, this
27259      instrumentation code *can* be reordered freely: as long as a
27260      VM instruction is counted, the count increment can be placed
27261      anyehere.  Let GCC move this code and possibly achieve better
27262      throughput by exploiting instruction-level parallelism and
27263      therefore approximate more closely a non-profiled build. */
27264   JITTER_PROFILE_COUNT_UPDATE
27265      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27266       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27267 #endif
27268 
27269 /* User-specified code, instruction-beginning-c part: beginning. */
27270 
27271 
27272 /* User-specified code, instruction-beginning-c part: end */
27273 
27274 
27275     /* User code for primitive-non-negativep/fR . */
27276 
27277     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
27278     JITTERLISP_NON_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
27279 
27280     /* End of the user code for primitive-non-negativep/fR . */
27281 
27282 /* User-specified code, instruction-end-c part: beginning. */
27283 
27284 
27285 /* User-specified code, instruction-end-c part: end */
27286 
27287     /* Undefine the primitive-non-negativep/fR argument macros so they can't be used
27288        by mistake in the instruction body coming next. */
27289 #   undef JITTER_SLOW_REGISTER_OFFSET0
27290 #   undef JITTER_ARG0
27291 #   undef JITTER_ARGN0
27292 #   undef JITTER_ARGU0
27293 #   undef JITTER_ARGP0
27294 #   undef JITTER_ARGF0
27295 
27296 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27297 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27298 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27299 
27300   }
27301  JITTER_INSTRUCTION_EPILOG_(primitive-non-negativep/fR, primitive_mnon_mnegativep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27302 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27303 
27304   JITTER_INSTRUCTION_PROLOG_(primitive-non-nullp, primitive_mnon_mnullp, hot)
27305   {
27306     /* This specialized instruction is not a replacement. */
27307 #   undef JITTER_BRANCH_FAST
27308 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27309 #   undef JITTER_BRANCH_FAST_IF_ZERO
27310 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27311 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27312 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27313 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27314 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27315 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27316 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27317 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27318 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27319 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27320 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27321 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27322 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27323 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27324 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27325 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27326 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27327 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27328 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27329 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27330 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27331 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27332 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27333 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27334 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27335 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27336 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27337 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27338 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27339 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27340 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27341 #   undef JITTER_BRANCH_FAST_IF_AND
27342 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27343 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27344 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27345 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27346 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27347 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27348 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27349 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27350 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27351 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27352 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27353 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27354 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27355 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27356 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27357 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27358 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27359 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27360 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27361 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27362 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27363 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27364 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27365 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27366 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27367 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27368 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27369 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27370 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27371 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       142
27372 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-nullp
27373 
27374 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mnullp
27375 
27376   /* The residual arity for this instruction does not depend on fast labels. */
27377   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27378 
27379 
27380 #if defined (JITTER_PROFILE_SAMPLE)
27381   JITTER_PROFILE_SAMPLE_UPDATE
27382      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27383       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27384   /* Force the compiler not move sample-profiling instrumentation
27385      beyond this point; this way the actual user code is timed.
27386      This is still not perfect, as residuals are materialised before
27387      we arrive here, but should be adequate at least for slow VM
27388      instructions. */
27389   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27390 #endif
27391 #if defined (JITTER_PROFILE_COUNT)
27392   /* Notice that, differently from the code above, this
27393      instrumentation code *can* be reordered freely: as long as a
27394      VM instruction is counted, the count increment can be placed
27395      anyehere.  Let GCC move this code and possibly achieve better
27396      throughput by exploiting instruction-level parallelism and
27397      therefore approximate more closely a non-profiled build. */
27398   JITTER_PROFILE_COUNT_UPDATE
27399      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27400       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27401 #endif
27402 
27403 /* User-specified code, instruction-beginning-c part: beginning. */
27404 
27405 
27406 /* User-specified code, instruction-beginning-c part: end */
27407 
27408 
27409     /* User code for primitive-non-nullp . */
27410 
27411     JITTERLISP_NON_NULLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
27412 
27413     /* End of the user code for primitive-non-nullp . */
27414 
27415 /* User-specified code, instruction-end-c part: beginning. */
27416 
27417 
27418 /* User-specified code, instruction-end-c part: end */
27419 
27420     /* Undefine the primitive-non-nullp argument macros so they can't be used
27421        by mistake in the instruction body coming next. */
27422 
27423 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27424 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27425 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27426 
27427   }
27428  JITTER_INSTRUCTION_EPILOG_(primitive-non-nullp, primitive_mnon_mnullp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27429 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27430 
27431   JITTER_INSTRUCTION_PROLOG_(primitive-non-positivep/fR, primitive_mnon_mpositivep__fR, hot)
27432   {
27433     /* This specialized instruction is not a replacement. */
27434 #   undef JITTER_BRANCH_FAST
27435 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27436 #   undef JITTER_BRANCH_FAST_IF_ZERO
27437 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27438 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27439 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27440 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27441 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27442 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27443 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27444 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27445 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27446 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27447 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27448 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27449 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27450 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27451 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27452 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27453 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27454 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27455 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27456 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27457 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27458 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27459 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27460 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27461 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27462 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27463 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27464 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27465 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27466 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27467 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27468 #   undef JITTER_BRANCH_FAST_IF_AND
27469 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27470 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27471 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27472 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27473 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27474 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27475 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27476 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27477 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27478 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27479 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27480 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27481 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27482 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27483 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27484 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27485 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27486 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27487 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27488 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27489 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27490 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27491 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27492 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27493 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27494 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27495 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27496 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27497 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27498 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       143
27499 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-positivep/fR
27500 
27501 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mpositivep__fR
27502 
27503   /* The residual arity varies depending on whether we have fast labels. */
27504 #ifdef JITTER_HAVE_PATCH_IN
27505   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27506 #else
27507   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
27508 #endif // #ifdef JITTER_HAVE_PATCH_IN
27509 
27510   /* Define argument-access macros for primitive-non-positivep/fR . */
27511 #ifdef JITTER_HAVE_PATCH_IN
27512   /* Define argument-access macros assuming that fast branches are enabled. */
27513     /* The 0th argument is a "residual" fast label.  Define its
27514        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
27515        so that at replication time we know what instruction address to patch in. */
27516 #   define JITTER_ARGF0 0
27517     /* JITTER_ARG0 is intentionally not defined for a fast label. */
27518 
27519 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27520 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27521 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27522 
27523 #else
27524   /* Define argument-access macros assuming that fast branches are disabled. */
27525 #if defined(JITTER_DISPATCH_NO_THREADING)
27526 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27527     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27528 #elif defined (JITTER_REPLICATE)
27529 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27530 #else
27531 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27532 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27533 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27534 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27535 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27536 #   define JITTER_ARGF0 JITTER_ARGP0
27537 
27538 # endif // #ifdef JITTER_HAVE_PATCH_IN
27539 
27540 #if defined (JITTER_PROFILE_SAMPLE)
27541   JITTER_PROFILE_SAMPLE_UPDATE
27542      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27543       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27544   /* Force the compiler not move sample-profiling instrumentation
27545      beyond this point; this way the actual user code is timed.
27546      This is still not perfect, as residuals are materialised before
27547      we arrive here, but should be adequate at least for slow VM
27548      instructions. */
27549   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27550 #endif
27551 #if defined (JITTER_PROFILE_COUNT)
27552   /* Notice that, differently from the code above, this
27553      instrumentation code *can* be reordered freely: as long as a
27554      VM instruction is counted, the count increment can be placed
27555      anyehere.  Let GCC move this code and possibly achieve better
27556      throughput by exploiting instruction-level parallelism and
27557      therefore approximate more closely a non-profiled build. */
27558   JITTER_PROFILE_COUNT_UPDATE
27559      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27560       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27561 #endif
27562 
27563 /* User-specified code, instruction-beginning-c part: beginning. */
27564 
27565 
27566 /* User-specified code, instruction-beginning-c part: end */
27567 
27568 
27569     /* User code for primitive-non-positivep/fR . */
27570 
27571     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
27572     JITTERLISP_NON_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
27573 
27574     /* End of the user code for primitive-non-positivep/fR . */
27575 
27576 /* User-specified code, instruction-end-c part: beginning. */
27577 
27578 
27579 /* User-specified code, instruction-end-c part: end */
27580 
27581     /* Undefine the primitive-non-positivep/fR argument macros so they can't be used
27582        by mistake in the instruction body coming next. */
27583 #   undef JITTER_SLOW_REGISTER_OFFSET0
27584 #   undef JITTER_ARG0
27585 #   undef JITTER_ARGN0
27586 #   undef JITTER_ARGU0
27587 #   undef JITTER_ARGP0
27588 #   undef JITTER_ARGF0
27589 
27590 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27591 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27592 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27593 
27594   }
27595  JITTER_INSTRUCTION_EPILOG_(primitive-non-positivep/fR, primitive_mnon_mpositivep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27596 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27597 
27598   JITTER_INSTRUCTION_PROLOG_(primitive-non-symbolp, primitive_mnon_msymbolp, hot)
27599   {
27600     /* This specialized instruction is not a replacement. */
27601 #   undef JITTER_BRANCH_FAST
27602 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27603 #   undef JITTER_BRANCH_FAST_IF_ZERO
27604 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27605 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27606 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27607 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27608 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27609 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27610 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27611 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27612 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27613 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27614 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27615 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27616 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27617 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27618 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27619 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27620 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27621 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27622 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27623 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27624 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27625 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27626 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27627 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27628 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27629 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27630 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27631 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27632 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27633 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27634 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27635 #   undef JITTER_BRANCH_FAST_IF_AND
27636 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27637 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27638 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27639 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27640 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27641 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27642 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27643 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27644 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27645 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27646 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27647 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27648 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27649 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27650 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27651 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27652 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27653 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27654 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27655 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27656 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27657 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27658 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27659 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27660 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27661 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27662 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27663 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27664 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27665 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       144
27666 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-symbolp
27667 
27668 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_msymbolp
27669 
27670   /* The residual arity for this instruction does not depend on fast labels. */
27671   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27672 
27673 
27674 #if defined (JITTER_PROFILE_SAMPLE)
27675   JITTER_PROFILE_SAMPLE_UPDATE
27676      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27677       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27678   /* Force the compiler not move sample-profiling instrumentation
27679      beyond this point; this way the actual user code is timed.
27680      This is still not perfect, as residuals are materialised before
27681      we arrive here, but should be adequate at least for slow VM
27682      instructions. */
27683   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27684 #endif
27685 #if defined (JITTER_PROFILE_COUNT)
27686   /* Notice that, differently from the code above, this
27687      instrumentation code *can* be reordered freely: as long as a
27688      VM instruction is counted, the count increment can be placed
27689      anyehere.  Let GCC move this code and possibly achieve better
27690      throughput by exploiting instruction-level parallelism and
27691      therefore approximate more closely a non-profiled build. */
27692   JITTER_PROFILE_COUNT_UPDATE
27693      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27694       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27695 #endif
27696 
27697 /* User-specified code, instruction-beginning-c part: beginning. */
27698 
27699 
27700 /* User-specified code, instruction-beginning-c part: end */
27701 
27702 
27703     /* User code for primitive-non-symbolp . */
27704 
27705     JITTERLISP_NON_SYMBOLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
27706 
27707     /* End of the user code for primitive-non-symbolp . */
27708 
27709 /* User-specified code, instruction-end-c part: beginning. */
27710 
27711 
27712 /* User-specified code, instruction-end-c part: end */
27713 
27714     /* Undefine the primitive-non-symbolp argument macros so they can't be used
27715        by mistake in the instruction body coming next. */
27716 
27717 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27718 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27719 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27720 
27721   }
27722  JITTER_INSTRUCTION_EPILOG_(primitive-non-symbolp, primitive_mnon_msymbolp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27723 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27724 
27725   JITTER_INSTRUCTION_PROLOG_(primitive-non-zerop/fR, primitive_mnon_mzerop__fR, hot)
27726   {
27727     /* This specialized instruction is not a replacement. */
27728 #   undef JITTER_BRANCH_FAST
27729 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27730 #   undef JITTER_BRANCH_FAST_IF_ZERO
27731 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27732 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27733 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27734 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27735 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27736 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27737 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27738 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27739 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27740 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27741 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27742 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27743 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27744 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27745 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27746 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27747 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27748 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27749 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27750 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27751 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27752 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27753 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27754 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27755 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27756 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27757 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27758 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27759 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27760 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27761 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27762 #   undef JITTER_BRANCH_FAST_IF_AND
27763 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27764 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27765 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27766 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27767 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27768 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27769 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27770 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27771 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27772 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27773 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27774 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27775 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27776 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27777 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27778 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27779 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27780 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27781 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27782 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27783 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27784 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27785 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27786 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27787 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27788 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27789 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27790 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27791 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27792 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       145
27793 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-non-zerop/fR
27794 
27795 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnon_mzerop__fR
27796 
27797   /* The residual arity varies depending on whether we have fast labels. */
27798 #ifdef JITTER_HAVE_PATCH_IN
27799   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27800 #else
27801   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
27802 #endif // #ifdef JITTER_HAVE_PATCH_IN
27803 
27804   /* Define argument-access macros for primitive-non-zerop/fR . */
27805 #ifdef JITTER_HAVE_PATCH_IN
27806   /* Define argument-access macros assuming that fast branches are enabled. */
27807     /* The 0th argument is a "residual" fast label.  Define its
27808        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
27809        so that at replication time we know what instruction address to patch in. */
27810 #   define JITTER_ARGF0 0
27811     /* JITTER_ARG0 is intentionally not defined for a fast label. */
27812 
27813 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27814 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27815 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27816 
27817 #else
27818   /* Define argument-access macros assuming that fast branches are disabled. */
27819 #if defined(JITTER_DISPATCH_NO_THREADING)
27820 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
27821     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
27822 #elif defined (JITTER_REPLICATE)
27823 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
27824 #else
27825 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
27826 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
27827 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
27828 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
27829 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
27830 #   define JITTER_ARGF0 JITTER_ARGP0
27831 
27832 # endif // #ifdef JITTER_HAVE_PATCH_IN
27833 
27834 #if defined (JITTER_PROFILE_SAMPLE)
27835   JITTER_PROFILE_SAMPLE_UPDATE
27836      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27837       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27838   /* Force the compiler not move sample-profiling instrumentation
27839      beyond this point; this way the actual user code is timed.
27840      This is still not perfect, as residuals are materialised before
27841      we arrive here, but should be adequate at least for slow VM
27842      instructions. */
27843   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27844 #endif
27845 #if defined (JITTER_PROFILE_COUNT)
27846   /* Notice that, differently from the code above, this
27847      instrumentation code *can* be reordered freely: as long as a
27848      VM instruction is counted, the count increment can be placed
27849      anyehere.  Let GCC move this code and possibly achieve better
27850      throughput by exploiting instruction-level parallelism and
27851      therefore approximate more closely a non-profiled build. */
27852   JITTER_PROFILE_COUNT_UPDATE
27853      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27854       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27855 #endif
27856 
27857 /* User-specified code, instruction-beginning-c part: beginning. */
27858 
27859 
27860 /* User-specified code, instruction-beginning-c part: end */
27861 
27862 
27863     /* User code for primitive-non-zerop/fR . */
27864 
27865     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
27866     JITTERLISP_NON_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
27867 
27868     /* End of the user code for primitive-non-zerop/fR . */
27869 
27870 /* User-specified code, instruction-end-c part: beginning. */
27871 
27872 
27873 /* User-specified code, instruction-end-c part: end */
27874 
27875     /* Undefine the primitive-non-zerop/fR argument macros so they can't be used
27876        by mistake in the instruction body coming next. */
27877 #   undef JITTER_SLOW_REGISTER_OFFSET0
27878 #   undef JITTER_ARG0
27879 #   undef JITTER_ARGN0
27880 #   undef JITTER_ARGU0
27881 #   undef JITTER_ARGP0
27882 #   undef JITTER_ARGF0
27883 
27884 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
27885 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
27886 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
27887 
27888   }
27889  JITTER_INSTRUCTION_EPILOG_(primitive-non-zerop/fR, primitive_mnon_mzerop__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
27890 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
27891 
27892   JITTER_INSTRUCTION_PROLOG_(primitive-not, primitive_mnot, hot)
27893   {
27894     /* This specialized instruction is not a replacement. */
27895 #   undef JITTER_BRANCH_FAST
27896 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
27897 #   undef JITTER_BRANCH_FAST_IF_ZERO
27898 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
27899 #   undef JITTER_BRANCH_FAST_IF_NONZERO
27900 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
27901 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
27902 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
27903 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
27904 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
27905 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
27906 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
27907 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
27908 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
27909 #   undef JITTER_BRANCH_FAST_IF_EQUAL
27910 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
27911 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
27912 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
27913 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
27914 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
27915 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27916 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
27917 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27918 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
27919 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27920 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
27921 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27922 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
27923 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27924 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
27925 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27926 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
27927 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27928 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
27929 #   undef JITTER_BRANCH_FAST_IF_AND
27930 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
27931 #   undef JITTER_BRANCH_FAST_IF_NOTAND
27932 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
27933 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27934 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
27935 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27936 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
27937 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27938 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
27939 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27940 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
27941 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27942 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
27943 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27944 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
27945 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27946 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
27947 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27948 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
27949 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27950 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
27951 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27952 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
27953 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27954 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
27955 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27956 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
27957 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27958 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
27959 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       146
27960 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not
27961 
27962 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot
27963 
27964   /* The residual arity for this instruction does not depend on fast labels. */
27965   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
27966 
27967 
27968 #if defined (JITTER_PROFILE_SAMPLE)
27969   JITTER_PROFILE_SAMPLE_UPDATE
27970      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27971       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27972   /* Force the compiler not move sample-profiling instrumentation
27973      beyond this point; this way the actual user code is timed.
27974      This is still not perfect, as residuals are materialised before
27975      we arrive here, but should be adequate at least for slow VM
27976      instructions. */
27977   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
27978 #endif
27979 #if defined (JITTER_PROFILE_COUNT)
27980   /* Notice that, differently from the code above, this
27981      instrumentation code *can* be reordered freely: as long as a
27982      VM instruction is counted, the count increment can be placed
27983      anyehere.  Let GCC move this code and possibly achieve better
27984      throughput by exploiting instruction-level parallelism and
27985      therefore approximate more closely a non-profiled build. */
27986   JITTER_PROFILE_COUNT_UPDATE
27987      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
27988       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
27989 #endif
27990 
27991 /* User-specified code, instruction-beginning-c part: beginning. */
27992 
27993 
27994 /* User-specified code, instruction-beginning-c part: end */
27995 
27996 
27997     /* User code for primitive-not . */
27998 
27999     JITTERLISP_NOT_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
28000 
28001     /* End of the user code for primitive-not . */
28002 
28003 /* User-specified code, instruction-end-c part: beginning. */
28004 
28005 
28006 /* User-specified code, instruction-end-c part: end */
28007 
28008     /* Undefine the primitive-not argument macros so they can't be used
28009        by mistake in the instruction body coming next. */
28010 
28011 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28012 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28013 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28014 
28015   }
28016  JITTER_INSTRUCTION_EPILOG_(primitive-not, primitive_mnot, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28017 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28018 
28019   JITTER_INSTRUCTION_PROLOG_(primitive-not-eqp, primitive_mnot_meqp, hot)
28020   {
28021     /* This specialized instruction is not a replacement. */
28022 #   undef JITTER_BRANCH_FAST
28023 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28024 #   undef JITTER_BRANCH_FAST_IF_ZERO
28025 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28026 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28027 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28028 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28029 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28030 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28031 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28032 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28033 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28034 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28035 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28036 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28037 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28038 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28039 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28040 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28041 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28042 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28043 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28044 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28045 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28046 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28047 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28048 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28049 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28050 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28051 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28052 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28053 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28054 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28055 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28056 #   undef JITTER_BRANCH_FAST_IF_AND
28057 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28058 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28059 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28060 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28061 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28062 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28063 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28064 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28065 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28066 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28067 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28068 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28069 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28070 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28071 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28072 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28073 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28074 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28075 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28076 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28077 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28078 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28079 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28080 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28081 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28082 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28083 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28084 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28085 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28086 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       147
28087 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not-eqp
28088 
28089 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot_meqp
28090 
28091   /* The residual arity for this instruction does not depend on fast labels. */
28092   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28093 
28094 
28095 #if defined (JITTER_PROFILE_SAMPLE)
28096   JITTER_PROFILE_SAMPLE_UPDATE
28097      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28098       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28099   /* Force the compiler not move sample-profiling instrumentation
28100      beyond this point; this way the actual user code is timed.
28101      This is still not perfect, as residuals are materialised before
28102      we arrive here, but should be adequate at least for slow VM
28103      instructions. */
28104   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28105 #endif
28106 #if defined (JITTER_PROFILE_COUNT)
28107   /* Notice that, differently from the code above, this
28108      instrumentation code *can* be reordered freely: as long as a
28109      VM instruction is counted, the count increment can be placed
28110      anyehere.  Let GCC move this code and possibly achieve better
28111      throughput by exploiting instruction-level parallelism and
28112      therefore approximate more closely a non-profiled build. */
28113   JITTER_PROFILE_COUNT_UPDATE
28114      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28115       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28116 #endif
28117 
28118 /* User-specified code, instruction-beginning-c part: beginning. */
28119 
28120 
28121 /* User-specified code, instruction-beginning-c part: end */
28122 
28123 
28124     /* User code for primitive-not-eqp . */
28125 
28126     JITTERLISP_NOT_EQP_(JITTER_TOP_MAINSTACK(),
28127                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
28128     JITTER_NIP_MAINSTACK();
28129 
28130     /* End of the user code for primitive-not-eqp . */
28131 
28132 /* User-specified code, instruction-end-c part: beginning. */
28133 
28134 
28135 /* User-specified code, instruction-end-c part: end */
28136 
28137     /* Undefine the primitive-not-eqp argument macros so they can't be used
28138        by mistake in the instruction body coming next. */
28139 
28140 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28141 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28142 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28143 
28144   }
28145  JITTER_INSTRUCTION_EPILOG_(primitive-not-eqp, primitive_mnot_meqp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28146 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28147 
28148   JITTER_INSTRUCTION_PROLOG_(primitive-not-greaterp/fR, primitive_mnot_mgreaterp__fR, hot)
28149   {
28150     /* This specialized instruction is not a replacement. */
28151 #   undef JITTER_BRANCH_FAST
28152 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28153 #   undef JITTER_BRANCH_FAST_IF_ZERO
28154 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28155 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28156 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28157 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28158 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28159 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28160 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28161 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28162 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28163 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28164 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28165 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28166 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28167 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28168 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28169 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28170 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28171 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28172 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28173 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28174 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28175 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28176 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28177 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28178 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28179 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28180 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28181 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28182 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28183 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28184 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28185 #   undef JITTER_BRANCH_FAST_IF_AND
28186 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28187 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28188 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28189 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28190 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28191 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28192 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28193 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28194 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28195 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28196 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28197 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28198 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28199 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28200 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28201 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28202 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28203 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28204 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28205 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28206 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28207 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28208 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28209 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28210 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28211 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28212 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28213 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28214 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28215 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       148
28216 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not-greaterp/fR
28217 
28218 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot_mgreaterp__fR
28219 
28220   /* The residual arity varies depending on whether we have fast labels. */
28221 #ifdef JITTER_HAVE_PATCH_IN
28222   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28223 #else
28224   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
28225 #endif // #ifdef JITTER_HAVE_PATCH_IN
28226 
28227   /* Define argument-access macros for primitive-not-greaterp/fR . */
28228 #ifdef JITTER_HAVE_PATCH_IN
28229   /* Define argument-access macros assuming that fast branches are enabled. */
28230     /* The 0th argument is a "residual" fast label.  Define its
28231        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
28232        so that at replication time we know what instruction address to patch in. */
28233 #   define JITTER_ARGF0 0
28234     /* JITTER_ARG0 is intentionally not defined for a fast label. */
28235 
28236 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28237 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28238 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28239 
28240 #else
28241   /* Define argument-access macros assuming that fast branches are disabled. */
28242 #if defined(JITTER_DISPATCH_NO_THREADING)
28243 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28244     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28245 #elif defined (JITTER_REPLICATE)
28246 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28247 #else
28248 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28249 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28250 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28251 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28252 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28253 #   define JITTER_ARGF0 JITTER_ARGP0
28254 
28255 # endif // #ifdef JITTER_HAVE_PATCH_IN
28256 
28257 #if defined (JITTER_PROFILE_SAMPLE)
28258   JITTER_PROFILE_SAMPLE_UPDATE
28259      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28260       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28261   /* Force the compiler not move sample-profiling instrumentation
28262      beyond this point; this way the actual user code is timed.
28263      This is still not perfect, as residuals are materialised before
28264      we arrive here, but should be adequate at least for slow VM
28265      instructions. */
28266   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28267 #endif
28268 #if defined (JITTER_PROFILE_COUNT)
28269   /* Notice that, differently from the code above, this
28270      instrumentation code *can* be reordered freely: as long as a
28271      VM instruction is counted, the count increment can be placed
28272      anyehere.  Let GCC move this code and possibly achieve better
28273      throughput by exploiting instruction-level parallelism and
28274      therefore approximate more closely a non-profiled build. */
28275   JITTER_PROFILE_COUNT_UPDATE
28276      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28277       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28278 #endif
28279 
28280 /* User-specified code, instruction-beginning-c part: beginning. */
28281 
28282 
28283 /* User-specified code, instruction-beginning-c part: end */
28284 
28285 
28286     /* User code for primitive-not-greaterp/fR . */
28287 
28288     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
28289     JITTERLISP_NOTGREATERP_(JITTER_TOP_MAINSTACK(),
28290                             JITTER_UNDER_TOP_MAINSTACK(),
28291                             JITTER_TOP_MAINSTACK());
28292     JITTER_NIP_MAINSTACK();
28293 
28294     /* End of the user code for primitive-not-greaterp/fR . */
28295 
28296 /* User-specified code, instruction-end-c part: beginning. */
28297 
28298 
28299 /* User-specified code, instruction-end-c part: end */
28300 
28301     /* Undefine the primitive-not-greaterp/fR argument macros so they can't be used
28302        by mistake in the instruction body coming next. */
28303 #   undef JITTER_SLOW_REGISTER_OFFSET0
28304 #   undef JITTER_ARG0
28305 #   undef JITTER_ARGN0
28306 #   undef JITTER_ARGU0
28307 #   undef JITTER_ARGP0
28308 #   undef JITTER_ARGF0
28309 
28310 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28311 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28312 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28313 
28314   }
28315  JITTER_INSTRUCTION_EPILOG_(primitive-not-greaterp/fR, primitive_mnot_mgreaterp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28316 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28317 
28318   JITTER_INSTRUCTION_PROLOG_(primitive-not-lessp/fR, primitive_mnot_mlessp__fR, hot)
28319   {
28320     /* This specialized instruction is not a replacement. */
28321 #   undef JITTER_BRANCH_FAST
28322 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28323 #   undef JITTER_BRANCH_FAST_IF_ZERO
28324 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28325 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28326 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28327 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28328 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28329 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28330 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28331 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28332 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28333 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28334 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28335 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28336 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28337 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28338 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28339 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28340 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28341 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28342 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28343 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28344 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28345 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28346 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28347 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28348 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28349 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28350 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28351 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28352 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28353 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28354 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28355 #   undef JITTER_BRANCH_FAST_IF_AND
28356 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28357 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28358 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28359 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28360 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28361 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28362 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28363 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28364 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28365 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28366 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28367 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28368 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28369 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28370 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28371 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28372 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28373 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28374 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28375 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28376 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28377 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28378 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28379 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28380 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28381 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28382 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28383 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28384 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28385 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       149
28386 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-not-lessp/fR
28387 
28388 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnot_mlessp__fR
28389 
28390   /* The residual arity varies depending on whether we have fast labels. */
28391 #ifdef JITTER_HAVE_PATCH_IN
28392   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28393 #else
28394   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
28395 #endif // #ifdef JITTER_HAVE_PATCH_IN
28396 
28397   /* Define argument-access macros for primitive-not-lessp/fR . */
28398 #ifdef JITTER_HAVE_PATCH_IN
28399   /* Define argument-access macros assuming that fast branches are enabled. */
28400     /* The 0th argument is a "residual" fast label.  Define its
28401        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
28402        so that at replication time we know what instruction address to patch in. */
28403 #   define JITTER_ARGF0 0
28404     /* JITTER_ARG0 is intentionally not defined for a fast label. */
28405 
28406 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28407 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28408 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28409 
28410 #else
28411   /* Define argument-access macros assuming that fast branches are disabled. */
28412 #if defined(JITTER_DISPATCH_NO_THREADING)
28413 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28414     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28415 #elif defined (JITTER_REPLICATE)
28416 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28417 #else
28418 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28419 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28420 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28421 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28422 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28423 #   define JITTER_ARGF0 JITTER_ARGP0
28424 
28425 # endif // #ifdef JITTER_HAVE_PATCH_IN
28426 
28427 #if defined (JITTER_PROFILE_SAMPLE)
28428   JITTER_PROFILE_SAMPLE_UPDATE
28429      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28430       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28431   /* Force the compiler not move sample-profiling instrumentation
28432      beyond this point; this way the actual user code is timed.
28433      This is still not perfect, as residuals are materialised before
28434      we arrive here, but should be adequate at least for slow VM
28435      instructions. */
28436   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28437 #endif
28438 #if defined (JITTER_PROFILE_COUNT)
28439   /* Notice that, differently from the code above, this
28440      instrumentation code *can* be reordered freely: as long as a
28441      VM instruction is counted, the count increment can be placed
28442      anyehere.  Let GCC move this code and possibly achieve better
28443      throughput by exploiting instruction-level parallelism and
28444      therefore approximate more closely a non-profiled build. */
28445   JITTER_PROFILE_COUNT_UPDATE
28446      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28447       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28448 #endif
28449 
28450 /* User-specified code, instruction-beginning-c part: beginning. */
28451 
28452 
28453 /* User-specified code, instruction-beginning-c part: end */
28454 
28455 
28456     /* User code for primitive-not-lessp/fR . */
28457 
28458     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
28459     JITTERLISP_NOTLESSP_(JITTER_TOP_MAINSTACK(),
28460                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
28461     JITTER_NIP_MAINSTACK();
28462 
28463     /* End of the user code for primitive-not-lessp/fR . */
28464 
28465 /* User-specified code, instruction-end-c part: beginning. */
28466 
28467 
28468 /* User-specified code, instruction-end-c part: end */
28469 
28470     /* Undefine the primitive-not-lessp/fR argument macros so they can't be used
28471        by mistake in the instruction body coming next. */
28472 #   undef JITTER_SLOW_REGISTER_OFFSET0
28473 #   undef JITTER_ARG0
28474 #   undef JITTER_ARGN0
28475 #   undef JITTER_ARGU0
28476 #   undef JITTER_ARGP0
28477 #   undef JITTER_ARGF0
28478 
28479 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28480 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28481 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28482 
28483   }
28484  JITTER_INSTRUCTION_EPILOG_(primitive-not-lessp/fR, primitive_mnot_mlessp__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28485 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28486 
28487   JITTER_INSTRUCTION_PROLOG_(primitive-nothingp, primitive_mnothingp, hot)
28488   {
28489     /* This specialized instruction is not a replacement. */
28490 #   undef JITTER_BRANCH_FAST
28491 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28492 #   undef JITTER_BRANCH_FAST_IF_ZERO
28493 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28494 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28495 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28496 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28497 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28498 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28499 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28500 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28501 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28502 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28503 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28504 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28505 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28506 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28507 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28508 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28509 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28510 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28511 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28512 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28513 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28514 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28515 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28516 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28517 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28518 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28519 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28520 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28521 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28522 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28523 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28524 #   undef JITTER_BRANCH_FAST_IF_AND
28525 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28526 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28527 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28528 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28529 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28530 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28531 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28532 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28533 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28534 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28535 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28536 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28537 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28538 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28539 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28540 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28541 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28542 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28543 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28544 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28545 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28546 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28547 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28548 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28549 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28550 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28551 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28552 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28553 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28554 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       150
28555 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-nothingp
28556 
28557 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnothingp
28558 
28559   /* The residual arity for this instruction does not depend on fast labels. */
28560   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28561 
28562 
28563 #if defined (JITTER_PROFILE_SAMPLE)
28564   JITTER_PROFILE_SAMPLE_UPDATE
28565      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28566       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28567   /* Force the compiler not move sample-profiling instrumentation
28568      beyond this point; this way the actual user code is timed.
28569      This is still not perfect, as residuals are materialised before
28570      we arrive here, but should be adequate at least for slow VM
28571      instructions. */
28572   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28573 #endif
28574 #if defined (JITTER_PROFILE_COUNT)
28575   /* Notice that, differently from the code above, this
28576      instrumentation code *can* be reordered freely: as long as a
28577      VM instruction is counted, the count increment can be placed
28578      anyehere.  Let GCC move this code and possibly achieve better
28579      throughput by exploiting instruction-level parallelism and
28580      therefore approximate more closely a non-profiled build. */
28581   JITTER_PROFILE_COUNT_UPDATE
28582      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28583       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28584 #endif
28585 
28586 /* User-specified code, instruction-beginning-c part: beginning. */
28587 
28588 
28589 /* User-specified code, instruction-beginning-c part: end */
28590 
28591 
28592     /* User code for primitive-nothingp . */
28593 
28594     JITTERLISP_NOTHINGP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
28595 
28596     /* End of the user code for primitive-nothingp . */
28597 
28598 /* User-specified code, instruction-end-c part: beginning. */
28599 
28600 
28601 /* User-specified code, instruction-end-c part: end */
28602 
28603     /* Undefine the primitive-nothingp argument macros so they can't be used
28604        by mistake in the instruction body coming next. */
28605 
28606 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28607 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28608 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28609 
28610   }
28611  JITTER_INSTRUCTION_EPILOG_(primitive-nothingp, primitive_mnothingp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28612 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28613 
28614   JITTER_INSTRUCTION_PROLOG_(primitive-nullp, primitive_mnullp, hot)
28615   {
28616     /* This specialized instruction is not a replacement. */
28617 #   undef JITTER_BRANCH_FAST
28618 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28619 #   undef JITTER_BRANCH_FAST_IF_ZERO
28620 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28621 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28622 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28623 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28624 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28625 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28626 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28627 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28628 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28629 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28630 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28631 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28632 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28633 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28634 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28635 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28636 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28637 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28638 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28639 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28640 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28641 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28642 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28643 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28644 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28645 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28646 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28647 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28648 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28649 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28650 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28651 #   undef JITTER_BRANCH_FAST_IF_AND
28652 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28653 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28654 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28655 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28656 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28657 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28658 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28659 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28660 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28661 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28662 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28663 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28664 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28665 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28666 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28667 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28668 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28669 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28670 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28671 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28672 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28673 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28674 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28675 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28676 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28677 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28678 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28679 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28680 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28681 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       151
28682 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-nullp
28683 
28684 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mnullp
28685 
28686   /* The residual arity for this instruction does not depend on fast labels. */
28687   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28688 
28689 
28690 #if defined (JITTER_PROFILE_SAMPLE)
28691   JITTER_PROFILE_SAMPLE_UPDATE
28692      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28693       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28694   /* Force the compiler not move sample-profiling instrumentation
28695      beyond this point; this way the actual user code is timed.
28696      This is still not perfect, as residuals are materialised before
28697      we arrive here, but should be adequate at least for slow VM
28698      instructions. */
28699   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28700 #endif
28701 #if defined (JITTER_PROFILE_COUNT)
28702   /* Notice that, differently from the code above, this
28703      instrumentation code *can* be reordered freely: as long as a
28704      VM instruction is counted, the count increment can be placed
28705      anyehere.  Let GCC move this code and possibly achieve better
28706      throughput by exploiting instruction-level parallelism and
28707      therefore approximate more closely a non-profiled build. */
28708   JITTER_PROFILE_COUNT_UPDATE
28709      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28710       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28711 #endif
28712 
28713 /* User-specified code, instruction-beginning-c part: beginning. */
28714 
28715 
28716 /* User-specified code, instruction-beginning-c part: end */
28717 
28718 
28719     /* User code for primitive-nullp . */
28720 
28721     JITTERLISP_NULLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
28722 
28723     /* End of the user code for primitive-nullp . */
28724 
28725 /* User-specified code, instruction-end-c part: beginning. */
28726 
28727 
28728 /* User-specified code, instruction-end-c part: end */
28729 
28730     /* Undefine the primitive-nullp argument macros so they can't be used
28731        by mistake in the instruction body coming next. */
28732 
28733 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28734 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28735 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28736 
28737   }
28738  JITTER_INSTRUCTION_EPILOG_(primitive-nullp, primitive_mnullp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28739 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28740 
28741   JITTER_INSTRUCTION_PROLOG_(primitive-one-minus/fR, primitive_mone_mminus__fR, hot)
28742   {
28743     /* This specialized instruction is not a replacement. */
28744 #   undef JITTER_BRANCH_FAST
28745 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28746 #   undef JITTER_BRANCH_FAST_IF_ZERO
28747 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28748 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28749 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28750 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28751 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28752 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28753 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28754 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28755 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28756 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28757 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28758 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28759 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28760 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28761 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28762 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28763 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28764 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28765 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28766 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28767 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28768 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28769 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28770 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28771 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28772 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28773 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28774 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28775 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28776 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28777 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28778 #   undef JITTER_BRANCH_FAST_IF_AND
28779 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28780 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28781 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28782 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28783 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28784 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28785 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28786 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28787 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28788 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28789 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28790 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28791 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28792 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28793 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28794 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28795 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28796 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28797 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28798 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28799 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28800 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28801 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28802 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28803 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28804 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28805 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28806 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28807 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28808 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       152
28809 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-one-minus/fR
28810 
28811 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mone_mminus__fR
28812 
28813   /* The residual arity varies depending on whether we have fast labels. */
28814 #ifdef JITTER_HAVE_PATCH_IN
28815   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28816 #else
28817   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
28818 #endif // #ifdef JITTER_HAVE_PATCH_IN
28819 
28820   /* Define argument-access macros for primitive-one-minus/fR . */
28821 #ifdef JITTER_HAVE_PATCH_IN
28822   /* Define argument-access macros assuming that fast branches are enabled. */
28823     /* The 0th argument is a "residual" fast label.  Define its
28824        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
28825        so that at replication time we know what instruction address to patch in. */
28826 #   define JITTER_ARGF0 0
28827     /* JITTER_ARG0 is intentionally not defined for a fast label. */
28828 
28829 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28830 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28831 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28832 
28833 #else
28834   /* Define argument-access macros assuming that fast branches are disabled. */
28835 #if defined(JITTER_DISPATCH_NO_THREADING)
28836 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
28837     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
28838 #elif defined (JITTER_REPLICATE)
28839 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
28840 #else
28841 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
28842 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
28843 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28844 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
28845 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
28846 #   define JITTER_ARGF0 JITTER_ARGP0
28847 
28848 # endif // #ifdef JITTER_HAVE_PATCH_IN
28849 
28850 #if defined (JITTER_PROFILE_SAMPLE)
28851   JITTER_PROFILE_SAMPLE_UPDATE
28852      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28853       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28854   /* Force the compiler not move sample-profiling instrumentation
28855      beyond this point; this way the actual user code is timed.
28856      This is still not perfect, as residuals are materialised before
28857      we arrive here, but should be adequate at least for slow VM
28858      instructions. */
28859   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
28860 #endif
28861 #if defined (JITTER_PROFILE_COUNT)
28862   /* Notice that, differently from the code above, this
28863      instrumentation code *can* be reordered freely: as long as a
28864      VM instruction is counted, the count increment can be placed
28865      anyehere.  Let GCC move this code and possibly achieve better
28866      throughput by exploiting instruction-level parallelism and
28867      therefore approximate more closely a non-profiled build. */
28868   JITTER_PROFILE_COUNT_UPDATE
28869      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
28870       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
28871 #endif
28872 
28873 /* User-specified code, instruction-beginning-c part: beginning. */
28874 
28875 
28876 /* User-specified code, instruction-beginning-c part: end */
28877 
28878 
28879     /* User code for primitive-one-minus/fR . */
28880 
28881     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
28882     JITTERLISP_1MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
28883                                    JITTER_TOP_MAINSTACK(),
28884                                    JITTER_ARGF0);
28885 
28886     /* End of the user code for primitive-one-minus/fR . */
28887 
28888 /* User-specified code, instruction-end-c part: beginning. */
28889 
28890 
28891 /* User-specified code, instruction-end-c part: end */
28892 
28893     /* Undefine the primitive-one-minus/fR argument macros so they can't be used
28894        by mistake in the instruction body coming next. */
28895 #   undef JITTER_SLOW_REGISTER_OFFSET0
28896 #   undef JITTER_ARG0
28897 #   undef JITTER_ARGN0
28898 #   undef JITTER_ARGU0
28899 #   undef JITTER_ARGP0
28900 #   undef JITTER_ARGF0
28901 
28902 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
28903 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
28904 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
28905 
28906   }
28907  JITTER_INSTRUCTION_EPILOG_(primitive-one-minus/fR, primitive_mone_mminus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
28908 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
28909 
28910   JITTER_INSTRUCTION_PROLOG_(primitive-one-plus/fR, primitive_mone_mplus__fR, hot)
28911   {
28912     /* This specialized instruction is not a replacement. */
28913 #   undef JITTER_BRANCH_FAST
28914 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
28915 #   undef JITTER_BRANCH_FAST_IF_ZERO
28916 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
28917 #   undef JITTER_BRANCH_FAST_IF_NONZERO
28918 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
28919 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
28920 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
28921 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
28922 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
28923 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
28924 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
28925 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
28926 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
28927 #   undef JITTER_BRANCH_FAST_IF_EQUAL
28928 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
28929 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
28930 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
28931 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
28932 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
28933 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28934 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
28935 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28936 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
28937 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28938 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
28939 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28940 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
28941 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28942 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
28943 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28944 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
28945 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28946 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
28947 #   undef JITTER_BRANCH_FAST_IF_AND
28948 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
28949 #   undef JITTER_BRANCH_FAST_IF_NOTAND
28950 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
28951 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28952 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
28953 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28954 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
28955 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28956 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
28957 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28958 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
28959 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28960 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
28961 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28962 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
28963 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28964 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
28965 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28966 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
28967 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28968 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
28969 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28970 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
28971 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28972 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
28973 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28974 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
28975 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28976 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
28977 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       153
28978 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-one-plus/fR
28979 
28980 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mone_mplus__fR
28981 
28982   /* The residual arity varies depending on whether we have fast labels. */
28983 #ifdef JITTER_HAVE_PATCH_IN
28984   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
28985 #else
28986   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
28987 #endif // #ifdef JITTER_HAVE_PATCH_IN
28988 
28989   /* Define argument-access macros for primitive-one-plus/fR . */
28990 #ifdef JITTER_HAVE_PATCH_IN
28991   /* Define argument-access macros assuming that fast branches are enabled. */
28992     /* The 0th argument is a "residual" fast label.  Define its
28993        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
28994        so that at replication time we know what instruction address to patch in. */
28995 #   define JITTER_ARGF0 0
28996     /* JITTER_ARG0 is intentionally not defined for a fast label. */
28997 
28998 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
28999 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29000 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29001 
29002 #else
29003   /* Define argument-access macros assuming that fast branches are disabled. */
29004 #if defined(JITTER_DISPATCH_NO_THREADING)
29005 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29006     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29007 #elif defined (JITTER_REPLICATE)
29008 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29009 #else
29010 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29011 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29012 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29013 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29014 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29015 #   define JITTER_ARGF0 JITTER_ARGP0
29016 
29017 # endif // #ifdef JITTER_HAVE_PATCH_IN
29018 
29019 #if defined (JITTER_PROFILE_SAMPLE)
29020   JITTER_PROFILE_SAMPLE_UPDATE
29021      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29022       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29023   /* Force the compiler not move sample-profiling instrumentation
29024      beyond this point; this way the actual user code is timed.
29025      This is still not perfect, as residuals are materialised before
29026      we arrive here, but should be adequate at least for slow VM
29027      instructions. */
29028   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29029 #endif
29030 #if defined (JITTER_PROFILE_COUNT)
29031   /* Notice that, differently from the code above, this
29032      instrumentation code *can* be reordered freely: as long as a
29033      VM instruction is counted, the count increment can be placed
29034      anyehere.  Let GCC move this code and possibly achieve better
29035      throughput by exploiting instruction-level parallelism and
29036      therefore approximate more closely a non-profiled build. */
29037   JITTER_PROFILE_COUNT_UPDATE
29038      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29039       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29040 #endif
29041 
29042 /* User-specified code, instruction-beginning-c part: beginning. */
29043 
29044 
29045 /* User-specified code, instruction-beginning-c part: end */
29046 
29047 
29048     /* User code for primitive-one-plus/fR . */
29049 
29050     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
29051     JITTERLISP_1PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
29052                                   JITTER_TOP_MAINSTACK(),
29053                                   JITTER_ARGF0);
29054 
29055     /* End of the user code for primitive-one-plus/fR . */
29056 
29057 /* User-specified code, instruction-end-c part: beginning. */
29058 
29059 
29060 /* User-specified code, instruction-end-c part: end */
29061 
29062     /* Undefine the primitive-one-plus/fR argument macros so they can't be used
29063        by mistake in the instruction body coming next. */
29064 #   undef JITTER_SLOW_REGISTER_OFFSET0
29065 #   undef JITTER_ARG0
29066 #   undef JITTER_ARGN0
29067 #   undef JITTER_ARGU0
29068 #   undef JITTER_ARGP0
29069 #   undef JITTER_ARGF0
29070 
29071 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29072 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29073 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29074 
29075   }
29076  JITTER_INSTRUCTION_EPILOG_(primitive-one-plus/fR, primitive_mone_mplus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29077 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29078 
29079   JITTER_INSTRUCTION_PROLOG_(primitive-positivep/fR, primitive_mpositivep__fR, hot)
29080   {
29081     /* This specialized instruction is not a replacement. */
29082 #   undef JITTER_BRANCH_FAST
29083 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29084 #   undef JITTER_BRANCH_FAST_IF_ZERO
29085 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29086 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29087 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29088 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29089 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29090 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29091 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29092 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29093 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29094 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29095 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29096 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29097 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29098 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29099 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29100 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29101 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29102 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29103 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29104 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29105 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29106 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29107 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29108 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29109 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29110 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29111 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29112 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29113 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29114 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29115 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29116 #   undef JITTER_BRANCH_FAST_IF_AND
29117 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29118 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29119 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29120 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29121 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29122 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29123 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29124 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29125 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29126 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29127 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29128 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29129 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29130 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29131 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29132 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29133 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29134 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29135 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29136 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29137 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29138 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29139 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29140 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29141 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29142 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29143 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29144 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29145 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29146 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       154
29147 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-positivep/fR
29148 
29149 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mpositivep__fR
29150 
29151   /* The residual arity varies depending on whether we have fast labels. */
29152 #ifdef JITTER_HAVE_PATCH_IN
29153   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
29154 #else
29155   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
29156 #endif // #ifdef JITTER_HAVE_PATCH_IN
29157 
29158   /* Define argument-access macros for primitive-positivep/fR . */
29159 #ifdef JITTER_HAVE_PATCH_IN
29160   /* Define argument-access macros assuming that fast branches are enabled. */
29161     /* The 0th argument is a "residual" fast label.  Define its
29162        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
29163        so that at replication time we know what instruction address to patch in. */
29164 #   define JITTER_ARGF0 0
29165     /* JITTER_ARG0 is intentionally not defined for a fast label. */
29166 
29167 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29168 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29169 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29170 
29171 #else
29172   /* Define argument-access macros assuming that fast branches are disabled. */
29173 #if defined(JITTER_DISPATCH_NO_THREADING)
29174 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29175     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29176 #elif defined (JITTER_REPLICATE)
29177 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29178 #else
29179 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29180 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29181 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29182 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29183 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29184 #   define JITTER_ARGF0 JITTER_ARGP0
29185 
29186 # endif // #ifdef JITTER_HAVE_PATCH_IN
29187 
29188 #if defined (JITTER_PROFILE_SAMPLE)
29189   JITTER_PROFILE_SAMPLE_UPDATE
29190      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29191       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29192   /* Force the compiler not move sample-profiling instrumentation
29193      beyond this point; this way the actual user code is timed.
29194      This is still not perfect, as residuals are materialised before
29195      we arrive here, but should be adequate at least for slow VM
29196      instructions. */
29197   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29198 #endif
29199 #if defined (JITTER_PROFILE_COUNT)
29200   /* Notice that, differently from the code above, this
29201      instrumentation code *can* be reordered freely: as long as a
29202      VM instruction is counted, the count increment can be placed
29203      anyehere.  Let GCC move this code and possibly achieve better
29204      throughput by exploiting instruction-level parallelism and
29205      therefore approximate more closely a non-profiled build. */
29206   JITTER_PROFILE_COUNT_UPDATE
29207      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29208       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29209 #endif
29210 
29211 /* User-specified code, instruction-beginning-c part: beginning. */
29212 
29213 
29214 /* User-specified code, instruction-beginning-c part: end */
29215 
29216 
29217     /* User code for primitive-positivep/fR . */
29218 
29219     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
29220     JITTERLISP_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
29221 
29222     /* End of the user code for primitive-positivep/fR . */
29223 
29224 /* User-specified code, instruction-end-c part: beginning. */
29225 
29226 
29227 /* User-specified code, instruction-end-c part: end */
29228 
29229     /* Undefine the primitive-positivep/fR argument macros so they can't be used
29230        by mistake in the instruction body coming next. */
29231 #   undef JITTER_SLOW_REGISTER_OFFSET0
29232 #   undef JITTER_ARG0
29233 #   undef JITTER_ARGN0
29234 #   undef JITTER_ARGU0
29235 #   undef JITTER_ARGP0
29236 #   undef JITTER_ARGF0
29237 
29238 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29239 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29240 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29241 
29242   }
29243  JITTER_INSTRUCTION_EPILOG_(primitive-positivep/fR, primitive_mpositivep__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29244 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29245 
29246   JITTER_INSTRUCTION_PROLOG_(primitive-primordial-divided/fR, primitive_mprimordial_mdivided__fR, hot)
29247   {
29248     /* This specialized instruction is not a replacement. */
29249 #   undef JITTER_BRANCH_FAST
29250 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29251 #   undef JITTER_BRANCH_FAST_IF_ZERO
29252 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29253 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29254 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29255 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29256 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29257 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29258 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29259 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29260 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29261 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29262 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29263 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29264 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29265 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29266 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29267 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29268 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29269 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29270 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29271 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29272 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29273 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29274 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29275 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29276 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29277 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29278 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29279 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29280 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29281 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29282 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29283 #   undef JITTER_BRANCH_FAST_IF_AND
29284 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29285 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29286 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29287 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29288 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29289 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29290 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29291 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29292 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29293 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29294 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29295 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29296 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29297 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29298 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29299 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29300 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29301 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29302 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29303 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29304 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29305 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29306 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29307 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29308 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29309 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29310 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29311 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29312 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29313 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       155
29314 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-divided/fR
29315 
29316 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mdivided__fR
29317 
29318   /* The residual arity varies depending on whether we have fast labels. */
29319 #ifdef JITTER_HAVE_PATCH_IN
29320   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
29321 #else
29322   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
29323 #endif // #ifdef JITTER_HAVE_PATCH_IN
29324 
29325   /* Define argument-access macros for primitive-primordial-divided/fR . */
29326 #ifdef JITTER_HAVE_PATCH_IN
29327   /* Define argument-access macros assuming that fast branches are enabled. */
29328     /* The 0th argument is a "residual" fast label.  Define its
29329        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
29330        so that at replication time we know what instruction address to patch in. */
29331 #   define JITTER_ARGF0 0
29332     /* JITTER_ARG0 is intentionally not defined for a fast label. */
29333 
29334 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29335 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29336 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29337 
29338 #else
29339   /* Define argument-access macros assuming that fast branches are disabled. */
29340 #if defined(JITTER_DISPATCH_NO_THREADING)
29341 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29342     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29343 #elif defined (JITTER_REPLICATE)
29344 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29345 #else
29346 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29347 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29348 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29349 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29350 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29351 #   define JITTER_ARGF0 JITTER_ARGP0
29352 
29353 # endif // #ifdef JITTER_HAVE_PATCH_IN
29354 
29355 #if defined (JITTER_PROFILE_SAMPLE)
29356   JITTER_PROFILE_SAMPLE_UPDATE
29357      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29358       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29359   /* Force the compiler not move sample-profiling instrumentation
29360      beyond this point; this way the actual user code is timed.
29361      This is still not perfect, as residuals are materialised before
29362      we arrive here, but should be adequate at least for slow VM
29363      instructions. */
29364   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29365 #endif
29366 #if defined (JITTER_PROFILE_COUNT)
29367   /* Notice that, differently from the code above, this
29368      instrumentation code *can* be reordered freely: as long as a
29369      VM instruction is counted, the count increment can be placed
29370      anyehere.  Let GCC move this code and possibly achieve better
29371      throughput by exploiting instruction-level parallelism and
29372      therefore approximate more closely a non-profiled build. */
29373   JITTER_PROFILE_COUNT_UPDATE
29374      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29375       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29376 #endif
29377 
29378 /* User-specified code, instruction-beginning-c part: beginning. */
29379 
29380 
29381 /* User-specified code, instruction-beginning-c part: end */
29382 
29383 
29384     /* User code for primitive-primordial-divided/fR . */
29385 
29386     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
29387     JITTERLISP_DIVIDED_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
29388                                     JITTER_UNDER_TOP_MAINSTACK(),
29389                                     JITTER_TOP_MAINSTACK(),
29390                                     JITTER_ARGF0);
29391     JITTER_NIP_MAINSTACK();
29392 
29393     /* End of the user code for primitive-primordial-divided/fR . */
29394 
29395 /* User-specified code, instruction-end-c part: beginning. */
29396 
29397 
29398 /* User-specified code, instruction-end-c part: end */
29399 
29400     /* Undefine the primitive-primordial-divided/fR argument macros so they can't be used
29401        by mistake in the instruction body coming next. */
29402 #   undef JITTER_SLOW_REGISTER_OFFSET0
29403 #   undef JITTER_ARG0
29404 #   undef JITTER_ARGN0
29405 #   undef JITTER_ARGU0
29406 #   undef JITTER_ARGP0
29407 #   undef JITTER_ARGF0
29408 
29409 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29410 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29411 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29412 
29413   }
29414  JITTER_INSTRUCTION_EPILOG_(primitive-primordial-divided/fR, primitive_mprimordial_mdivided__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29415 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29416 
29417   JITTER_INSTRUCTION_PROLOG_(primitive-primordial-divided-unsafe/fR, primitive_mprimordial_mdivided_munsafe__fR, hot)
29418   {
29419     /* This specialized instruction is not a replacement. */
29420 #   undef JITTER_BRANCH_FAST
29421 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29422 #   undef JITTER_BRANCH_FAST_IF_ZERO
29423 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29424 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29425 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29426 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29427 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29428 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29429 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29430 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29431 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29432 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29433 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29434 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29435 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29436 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29437 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29438 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29439 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29440 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29441 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29442 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29443 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29444 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29445 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29446 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29447 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29448 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29449 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29450 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29451 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29452 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29453 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29454 #   undef JITTER_BRANCH_FAST_IF_AND
29455 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29456 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29457 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29458 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29459 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29460 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29461 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29462 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29463 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29464 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29465 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29466 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29467 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29468 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29469 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29470 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29471 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29472 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29473 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29474 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29475 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29476 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29477 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29478 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29479 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29480 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29481 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29482 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29483 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29484 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       156
29485 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-divided-unsafe/fR
29486 
29487 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mdivided_munsafe__fR
29488 
29489   /* The residual arity varies depending on whether we have fast labels. */
29490 #ifdef JITTER_HAVE_PATCH_IN
29491   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
29492 #else
29493   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
29494 #endif // #ifdef JITTER_HAVE_PATCH_IN
29495 
29496   /* Define argument-access macros for primitive-primordial-divided-unsafe/fR . */
29497 #ifdef JITTER_HAVE_PATCH_IN
29498   /* Define argument-access macros assuming that fast branches are enabled. */
29499     /* The 0th argument is a "residual" fast label.  Define its
29500        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
29501        so that at replication time we know what instruction address to patch in. */
29502 #   define JITTER_ARGF0 0
29503     /* JITTER_ARG0 is intentionally not defined for a fast label. */
29504 
29505 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29506 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29507 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29508 
29509 #else
29510   /* Define argument-access macros assuming that fast branches are disabled. */
29511 #if defined(JITTER_DISPATCH_NO_THREADING)
29512 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29513     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29514 #elif defined (JITTER_REPLICATE)
29515 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29516 #else
29517 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29518 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29519 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29520 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29521 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29522 #   define JITTER_ARGF0 JITTER_ARGP0
29523 
29524 # endif // #ifdef JITTER_HAVE_PATCH_IN
29525 
29526 #if defined (JITTER_PROFILE_SAMPLE)
29527   JITTER_PROFILE_SAMPLE_UPDATE
29528      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29529       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29530   /* Force the compiler not move sample-profiling instrumentation
29531      beyond this point; this way the actual user code is timed.
29532      This is still not perfect, as residuals are materialised before
29533      we arrive here, but should be adequate at least for slow VM
29534      instructions. */
29535   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29536 #endif
29537 #if defined (JITTER_PROFILE_COUNT)
29538   /* Notice that, differently from the code above, this
29539      instrumentation code *can* be reordered freely: as long as a
29540      VM instruction is counted, the count increment can be placed
29541      anyehere.  Let GCC move this code and possibly achieve better
29542      throughput by exploiting instruction-level parallelism and
29543      therefore approximate more closely a non-profiled build. */
29544   JITTER_PROFILE_COUNT_UPDATE
29545      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29546       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29547 #endif
29548 
29549 /* User-specified code, instruction-beginning-c part: beginning. */
29550 
29551 
29552 /* User-specified code, instruction-beginning-c part: end */
29553 
29554 
29555     /* User code for primitive-primordial-divided-unsafe/fR . */
29556 
29557     /* The second argument has already been validated if we are using this. */
29558     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
29559     JITTERLISP_DIVIDED_UNSAFE_(JITTER_TOP_MAINSTACK(),
29560                                JITTER_UNDER_TOP_MAINSTACK(),
29561                                JITTER_TOP_MAINSTACK());
29562     JITTER_NIP_MAINSTACK();
29563 
29564     /* End of the user code for primitive-primordial-divided-unsafe/fR . */
29565 
29566 /* User-specified code, instruction-end-c part: beginning. */
29567 
29568 
29569 /* User-specified code, instruction-end-c part: end */
29570 
29571     /* Undefine the primitive-primordial-divided-unsafe/fR argument macros so they can't be used
29572        by mistake in the instruction body coming next. */
29573 #   undef JITTER_SLOW_REGISTER_OFFSET0
29574 #   undef JITTER_ARG0
29575 #   undef JITTER_ARGN0
29576 #   undef JITTER_ARGU0
29577 #   undef JITTER_ARGP0
29578 #   undef JITTER_ARGF0
29579 
29580 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29581 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29582 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29583 
29584   }
29585  JITTER_INSTRUCTION_EPILOG_(primitive-primordial-divided-unsafe/fR, primitive_mprimordial_mdivided_munsafe__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29586 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29587 
29588   JITTER_INSTRUCTION_PROLOG_(primitive-primordial-minus/fR, primitive_mprimordial_mminus__fR, hot)
29589   {
29590     /* This specialized instruction is not a replacement. */
29591 #   undef JITTER_BRANCH_FAST
29592 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29593 #   undef JITTER_BRANCH_FAST_IF_ZERO
29594 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29595 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29596 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29597 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29598 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29599 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29600 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29601 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29602 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29603 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29604 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29605 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29606 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29607 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29608 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29609 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29610 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29611 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29612 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29613 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29614 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29615 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29616 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29617 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29618 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29619 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29620 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29621 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29622 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29623 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29624 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29625 #   undef JITTER_BRANCH_FAST_IF_AND
29626 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29627 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29628 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29629 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29630 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29631 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29632 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29633 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29634 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29635 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29636 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29637 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29638 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29639 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29640 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29641 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29642 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29643 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29644 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29645 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29646 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29647 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29648 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29649 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29650 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29651 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29652 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29653 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29654 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29655 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       157
29656 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-minus/fR
29657 
29658 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mminus__fR
29659 
29660   /* The residual arity varies depending on whether we have fast labels. */
29661 #ifdef JITTER_HAVE_PATCH_IN
29662   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
29663 #else
29664   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
29665 #endif // #ifdef JITTER_HAVE_PATCH_IN
29666 
29667   /* Define argument-access macros for primitive-primordial-minus/fR . */
29668 #ifdef JITTER_HAVE_PATCH_IN
29669   /* Define argument-access macros assuming that fast branches are enabled. */
29670     /* The 0th argument is a "residual" fast label.  Define its
29671        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
29672        so that at replication time we know what instruction address to patch in. */
29673 #   define JITTER_ARGF0 0
29674     /* JITTER_ARG0 is intentionally not defined for a fast label. */
29675 
29676 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29677 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29678 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29679 
29680 #else
29681   /* Define argument-access macros assuming that fast branches are disabled. */
29682 #if defined(JITTER_DISPATCH_NO_THREADING)
29683 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29684     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29685 #elif defined (JITTER_REPLICATE)
29686 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29687 #else
29688 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29689 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29690 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29691 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29692 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29693 #   define JITTER_ARGF0 JITTER_ARGP0
29694 
29695 # endif // #ifdef JITTER_HAVE_PATCH_IN
29696 
29697 #if defined (JITTER_PROFILE_SAMPLE)
29698   JITTER_PROFILE_SAMPLE_UPDATE
29699      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29700       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29701   /* Force the compiler not move sample-profiling instrumentation
29702      beyond this point; this way the actual user code is timed.
29703      This is still not perfect, as residuals are materialised before
29704      we arrive here, but should be adequate at least for slow VM
29705      instructions. */
29706   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29707 #endif
29708 #if defined (JITTER_PROFILE_COUNT)
29709   /* Notice that, differently from the code above, this
29710      instrumentation code *can* be reordered freely: as long as a
29711      VM instruction is counted, the count increment can be placed
29712      anyehere.  Let GCC move this code and possibly achieve better
29713      throughput by exploiting instruction-level parallelism and
29714      therefore approximate more closely a non-profiled build. */
29715   JITTER_PROFILE_COUNT_UPDATE
29716      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29717       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29718 #endif
29719 
29720 /* User-specified code, instruction-beginning-c part: beginning. */
29721 
29722 
29723 /* User-specified code, instruction-beginning-c part: end */
29724 
29725 
29726     /* User code for primitive-primordial-minus/fR . */
29727 
29728     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
29729     JITTERLISP_MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
29730                                   JITTER_UNDER_TOP_MAINSTACK(),
29731                                   JITTER_TOP_MAINSTACK(),
29732                                   JITTER_ARGF0);
29733     JITTER_NIP_MAINSTACK();
29734 
29735     /* End of the user code for primitive-primordial-minus/fR . */
29736 
29737 /* User-specified code, instruction-end-c part: beginning. */
29738 
29739 
29740 /* User-specified code, instruction-end-c part: end */
29741 
29742     /* Undefine the primitive-primordial-minus/fR argument macros so they can't be used
29743        by mistake in the instruction body coming next. */
29744 #   undef JITTER_SLOW_REGISTER_OFFSET0
29745 #   undef JITTER_ARG0
29746 #   undef JITTER_ARGN0
29747 #   undef JITTER_ARGU0
29748 #   undef JITTER_ARGP0
29749 #   undef JITTER_ARGF0
29750 
29751 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29752 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29753 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29754 
29755   }
29756  JITTER_INSTRUCTION_EPILOG_(primitive-primordial-minus/fR, primitive_mprimordial_mminus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29757 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29758 
29759   JITTER_INSTRUCTION_PROLOG_(primitive-primordial-plus/fR, primitive_mprimordial_mplus__fR, hot)
29760   {
29761     /* This specialized instruction is not a replacement. */
29762 #   undef JITTER_BRANCH_FAST
29763 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29764 #   undef JITTER_BRANCH_FAST_IF_ZERO
29765 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29766 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29767 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29768 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29769 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29770 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29771 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29772 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29773 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29774 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29775 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29776 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29777 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29778 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29779 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29780 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29781 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29782 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29783 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29784 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29785 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29786 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29787 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29788 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29789 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29790 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29791 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29792 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29793 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29794 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29795 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29796 #   undef JITTER_BRANCH_FAST_IF_AND
29797 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29798 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29799 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29800 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29801 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29802 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29803 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29804 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29805 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29806 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29807 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29808 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29809 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29810 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29811 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29812 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29813 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29814 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29815 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29816 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29817 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29818 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29819 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29820 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29821 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29822 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29823 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29824 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29825 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29826 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       158
29827 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-plus/fR
29828 
29829 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mplus__fR
29830 
29831   /* The residual arity varies depending on whether we have fast labels. */
29832 #ifdef JITTER_HAVE_PATCH_IN
29833   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
29834 #else
29835   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
29836 #endif // #ifdef JITTER_HAVE_PATCH_IN
29837 
29838   /* Define argument-access macros for primitive-primordial-plus/fR . */
29839 #ifdef JITTER_HAVE_PATCH_IN
29840   /* Define argument-access macros assuming that fast branches are enabled. */
29841     /* The 0th argument is a "residual" fast label.  Define its
29842        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
29843        so that at replication time we know what instruction address to patch in. */
29844 #   define JITTER_ARGF0 0
29845     /* JITTER_ARG0 is intentionally not defined for a fast label. */
29846 
29847 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29848 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29849 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29850 
29851 #else
29852   /* Define argument-access macros assuming that fast branches are disabled. */
29853 #if defined(JITTER_DISPATCH_NO_THREADING)
29854 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
29855     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
29856 #elif defined (JITTER_REPLICATE)
29857 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
29858 #else
29859 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
29860 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
29861 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
29862 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
29863 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
29864 #   define JITTER_ARGF0 JITTER_ARGP0
29865 
29866 # endif // #ifdef JITTER_HAVE_PATCH_IN
29867 
29868 #if defined (JITTER_PROFILE_SAMPLE)
29869   JITTER_PROFILE_SAMPLE_UPDATE
29870      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29871       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29872   /* Force the compiler not move sample-profiling instrumentation
29873      beyond this point; this way the actual user code is timed.
29874      This is still not perfect, as residuals are materialised before
29875      we arrive here, but should be adequate at least for slow VM
29876      instructions. */
29877   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
29878 #endif
29879 #if defined (JITTER_PROFILE_COUNT)
29880   /* Notice that, differently from the code above, this
29881      instrumentation code *can* be reordered freely: as long as a
29882      VM instruction is counted, the count increment can be placed
29883      anyehere.  Let GCC move this code and possibly achieve better
29884      throughput by exploiting instruction-level parallelism and
29885      therefore approximate more closely a non-profiled build. */
29886   JITTER_PROFILE_COUNT_UPDATE
29887      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
29888       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
29889 #endif
29890 
29891 /* User-specified code, instruction-beginning-c part: beginning. */
29892 
29893 
29894 /* User-specified code, instruction-beginning-c part: end */
29895 
29896 
29897     /* User code for primitive-primordial-plus/fR . */
29898 
29899     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
29900     JITTERLISP_PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
29901                                  JITTER_UNDER_TOP_MAINSTACK(),
29902                                  JITTER_TOP_MAINSTACK(),
29903                                  JITTER_ARGF0);
29904     JITTER_NIP_MAINSTACK();
29905 
29906     /* End of the user code for primitive-primordial-plus/fR . */
29907 
29908 /* User-specified code, instruction-end-c part: beginning. */
29909 
29910 
29911 /* User-specified code, instruction-end-c part: end */
29912 
29913     /* Undefine the primitive-primordial-plus/fR argument macros so they can't be used
29914        by mistake in the instruction body coming next. */
29915 #   undef JITTER_SLOW_REGISTER_OFFSET0
29916 #   undef JITTER_ARG0
29917 #   undef JITTER_ARGN0
29918 #   undef JITTER_ARGU0
29919 #   undef JITTER_ARGP0
29920 #   undef JITTER_ARGF0
29921 
29922 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
29923 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
29924 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
29925 
29926   }
29927  JITTER_INSTRUCTION_EPILOG_(primitive-primordial-plus/fR, primitive_mprimordial_mplus__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
29928 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
29929 
29930   JITTER_INSTRUCTION_PROLOG_(primitive-primordial-times/fR, primitive_mprimordial_mtimes__fR, hot)
29931   {
29932     /* This specialized instruction is not a replacement. */
29933 #   undef JITTER_BRANCH_FAST
29934 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
29935 #   undef JITTER_BRANCH_FAST_IF_ZERO
29936 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
29937 #   undef JITTER_BRANCH_FAST_IF_NONZERO
29938 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
29939 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
29940 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
29941 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
29942 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
29943 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
29944 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
29945 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
29946 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
29947 #   undef JITTER_BRANCH_FAST_IF_EQUAL
29948 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
29949 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
29950 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
29951 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
29952 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
29953 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29954 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
29955 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29956 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
29957 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29958 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
29959 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29960 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
29961 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29962 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
29963 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29964 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
29965 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29966 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
29967 #   undef JITTER_BRANCH_FAST_IF_AND
29968 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
29969 #   undef JITTER_BRANCH_FAST_IF_NOTAND
29970 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
29971 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29972 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
29973 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29974 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
29975 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29976 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
29977 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29978 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
29979 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29980 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
29981 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29982 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
29983 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29984 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
29985 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29986 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
29987 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29988 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
29989 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29990 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
29991 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29992 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
29993 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29994 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
29995 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29996 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
29997 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       159
29998 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-primordial-times/fR
29999 
30000 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mprimordial_mtimes__fR
30001 
30002   /* The residual arity varies depending on whether we have fast labels. */
30003 #ifdef JITTER_HAVE_PATCH_IN
30004   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30005 #else
30006   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
30007 #endif // #ifdef JITTER_HAVE_PATCH_IN
30008 
30009   /* Define argument-access macros for primitive-primordial-times/fR . */
30010 #ifdef JITTER_HAVE_PATCH_IN
30011   /* Define argument-access macros assuming that fast branches are enabled. */
30012     /* The 0th argument is a "residual" fast label.  Define its
30013        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
30014        so that at replication time we know what instruction address to patch in. */
30015 #   define JITTER_ARGF0 0
30016     /* JITTER_ARG0 is intentionally not defined for a fast label. */
30017 
30018 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30019 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30020 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30021 
30022 #else
30023   /* Define argument-access macros assuming that fast branches are disabled. */
30024 #if defined(JITTER_DISPATCH_NO_THREADING)
30025 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
30026     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
30027 #elif defined (JITTER_REPLICATE)
30028 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
30029 #else
30030 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
30031 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
30032 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30033 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30034 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30035 #   define JITTER_ARGF0 JITTER_ARGP0
30036 
30037 # endif // #ifdef JITTER_HAVE_PATCH_IN
30038 
30039 #if defined (JITTER_PROFILE_SAMPLE)
30040   JITTER_PROFILE_SAMPLE_UPDATE
30041      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30042       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30043   /* Force the compiler not move sample-profiling instrumentation
30044      beyond this point; this way the actual user code is timed.
30045      This is still not perfect, as residuals are materialised before
30046      we arrive here, but should be adequate at least for slow VM
30047      instructions. */
30048   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30049 #endif
30050 #if defined (JITTER_PROFILE_COUNT)
30051   /* Notice that, differently from the code above, this
30052      instrumentation code *can* be reordered freely: as long as a
30053      VM instruction is counted, the count increment can be placed
30054      anyehere.  Let GCC move this code and possibly achieve better
30055      throughput by exploiting instruction-level parallelism and
30056      therefore approximate more closely a non-profiled build. */
30057   JITTER_PROFILE_COUNT_UPDATE
30058      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30059       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30060 #endif
30061 
30062 /* User-specified code, instruction-beginning-c part: beginning. */
30063 
30064 
30065 /* User-specified code, instruction-beginning-c part: end */
30066 
30067 
30068     /* User code for primitive-primordial-times/fR . */
30069 
30070     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
30071     JITTERLISP_TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
30072                                   JITTER_UNDER_TOP_MAINSTACK(),
30073                                   JITTER_TOP_MAINSTACK(),
30074                                   JITTER_ARGF0);
30075     JITTER_NIP_MAINSTACK();
30076 
30077     /* End of the user code for primitive-primordial-times/fR . */
30078 
30079 /* User-specified code, instruction-end-c part: beginning. */
30080 
30081 
30082 /* User-specified code, instruction-end-c part: end */
30083 
30084     /* Undefine the primitive-primordial-times/fR argument macros so they can't be used
30085        by mistake in the instruction body coming next. */
30086 #   undef JITTER_SLOW_REGISTER_OFFSET0
30087 #   undef JITTER_ARG0
30088 #   undef JITTER_ARGN0
30089 #   undef JITTER_ARGU0
30090 #   undef JITTER_ARGP0
30091 #   undef JITTER_ARGF0
30092 
30093 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30094 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30095 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30096 
30097   }
30098  JITTER_INSTRUCTION_EPILOG_(primitive-primordial-times/fR, primitive_mprimordial_mtimes__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30099 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30100 
30101   JITTER_INSTRUCTION_PROLOG_(primitive-quotient/fR, primitive_mquotient__fR, hot)
30102   {
30103     /* This specialized instruction is not a replacement. */
30104 #   undef JITTER_BRANCH_FAST
30105 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30106 #   undef JITTER_BRANCH_FAST_IF_ZERO
30107 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30108 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30109 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30110 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30111 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30112 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30113 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30114 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30115 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30116 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30117 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30118 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30119 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30120 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30121 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30122 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30123 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30124 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30125 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30126 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30127 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30128 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30129 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30130 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30131 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30132 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30133 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30134 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30135 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30136 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30137 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30138 #   undef JITTER_BRANCH_FAST_IF_AND
30139 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30140 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30141 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30142 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30143 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30144 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30145 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30146 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30147 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30148 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30149 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30150 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30151 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30152 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30153 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30154 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30155 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30156 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30157 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30158 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30159 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30160 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30161 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30162 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30163 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30164 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30165 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30166 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30167 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30168 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       160
30169 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-quotient/fR
30170 
30171 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mquotient__fR
30172 
30173   /* The residual arity varies depending on whether we have fast labels. */
30174 #ifdef JITTER_HAVE_PATCH_IN
30175   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30176 #else
30177   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
30178 #endif // #ifdef JITTER_HAVE_PATCH_IN
30179 
30180   /* Define argument-access macros for primitive-quotient/fR . */
30181 #ifdef JITTER_HAVE_PATCH_IN
30182   /* Define argument-access macros assuming that fast branches are enabled. */
30183     /* The 0th argument is a "residual" fast label.  Define its
30184        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
30185        so that at replication time we know what instruction address to patch in. */
30186 #   define JITTER_ARGF0 0
30187     /* JITTER_ARG0 is intentionally not defined for a fast label. */
30188 
30189 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30190 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30191 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30192 
30193 #else
30194   /* Define argument-access macros assuming that fast branches are disabled. */
30195 #if defined(JITTER_DISPATCH_NO_THREADING)
30196 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
30197     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
30198 #elif defined (JITTER_REPLICATE)
30199 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
30200 #else
30201 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
30202 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
30203 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30204 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30205 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30206 #   define JITTER_ARGF0 JITTER_ARGP0
30207 
30208 # endif // #ifdef JITTER_HAVE_PATCH_IN
30209 
30210 #if defined (JITTER_PROFILE_SAMPLE)
30211   JITTER_PROFILE_SAMPLE_UPDATE
30212      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30213       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30214   /* Force the compiler not move sample-profiling instrumentation
30215      beyond this point; this way the actual user code is timed.
30216      This is still not perfect, as residuals are materialised before
30217      we arrive here, but should be adequate at least for slow VM
30218      instructions. */
30219   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30220 #endif
30221 #if defined (JITTER_PROFILE_COUNT)
30222   /* Notice that, differently from the code above, this
30223      instrumentation code *can* be reordered freely: as long as a
30224      VM instruction is counted, the count increment can be placed
30225      anyehere.  Let GCC move this code and possibly achieve better
30226      throughput by exploiting instruction-level parallelism and
30227      therefore approximate more closely a non-profiled build. */
30228   JITTER_PROFILE_COUNT_UPDATE
30229      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30230       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30231 #endif
30232 
30233 /* User-specified code, instruction-beginning-c part: beginning. */
30234 
30235 
30236 /* User-specified code, instruction-beginning-c part: end */
30237 
30238 
30239     /* User code for primitive-quotient/fR . */
30240 
30241     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
30242     JITTERLISP_QUOTIENT_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
30243                                      JITTER_UNDER_TOP_MAINSTACK(),
30244                                      JITTER_TOP_MAINSTACK(),
30245                                      JITTER_ARGF0);
30246     JITTER_NIP_MAINSTACK();
30247 
30248     /* End of the user code for primitive-quotient/fR . */
30249 
30250 /* User-specified code, instruction-end-c part: beginning. */
30251 
30252 
30253 /* User-specified code, instruction-end-c part: end */
30254 
30255     /* Undefine the primitive-quotient/fR argument macros so they can't be used
30256        by mistake in the instruction body coming next. */
30257 #   undef JITTER_SLOW_REGISTER_OFFSET0
30258 #   undef JITTER_ARG0
30259 #   undef JITTER_ARGN0
30260 #   undef JITTER_ARGU0
30261 #   undef JITTER_ARGP0
30262 #   undef JITTER_ARGF0
30263 
30264 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30265 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30266 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30267 
30268   }
30269  JITTER_INSTRUCTION_EPILOG_(primitive-quotient/fR, primitive_mquotient__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30270 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30271 
30272   JITTER_INSTRUCTION_PROLOG_(primitive-quotient-unsafe/fR, primitive_mquotient_munsafe__fR, hot)
30273   {
30274     /* This specialized instruction is not a replacement. */
30275 #   undef JITTER_BRANCH_FAST
30276 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30277 #   undef JITTER_BRANCH_FAST_IF_ZERO
30278 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30279 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30280 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30281 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30282 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30283 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30284 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30285 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30286 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30287 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30288 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30289 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30290 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30291 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30292 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30293 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30294 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30295 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30296 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30297 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30298 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30299 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30300 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30301 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30302 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30303 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30304 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30305 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30306 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30307 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30308 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30309 #   undef JITTER_BRANCH_FAST_IF_AND
30310 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30311 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30312 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30313 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30314 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30315 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30316 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30317 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30318 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30319 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30320 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30321 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30322 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30323 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30324 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30325 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30326 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30327 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30328 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30329 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30330 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30331 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30332 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30333 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30334 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30335 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30336 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30337 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30338 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30339 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       161
30340 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-quotient-unsafe/fR
30341 
30342 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mquotient_munsafe__fR
30343 
30344   /* The residual arity varies depending on whether we have fast labels. */
30345 #ifdef JITTER_HAVE_PATCH_IN
30346   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30347 #else
30348   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
30349 #endif // #ifdef JITTER_HAVE_PATCH_IN
30350 
30351   /* Define argument-access macros for primitive-quotient-unsafe/fR . */
30352 #ifdef JITTER_HAVE_PATCH_IN
30353   /* Define argument-access macros assuming that fast branches are enabled. */
30354     /* The 0th argument is a "residual" fast label.  Define its
30355        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
30356        so that at replication time we know what instruction address to patch in. */
30357 #   define JITTER_ARGF0 0
30358     /* JITTER_ARG0 is intentionally not defined for a fast label. */
30359 
30360 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30361 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30362 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30363 
30364 #else
30365   /* Define argument-access macros assuming that fast branches are disabled. */
30366 #if defined(JITTER_DISPATCH_NO_THREADING)
30367 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
30368     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
30369 #elif defined (JITTER_REPLICATE)
30370 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
30371 #else
30372 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
30373 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
30374 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30375 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30376 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30377 #   define JITTER_ARGF0 JITTER_ARGP0
30378 
30379 # endif // #ifdef JITTER_HAVE_PATCH_IN
30380 
30381 #if defined (JITTER_PROFILE_SAMPLE)
30382   JITTER_PROFILE_SAMPLE_UPDATE
30383      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30384       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30385   /* Force the compiler not move sample-profiling instrumentation
30386      beyond this point; this way the actual user code is timed.
30387      This is still not perfect, as residuals are materialised before
30388      we arrive here, but should be adequate at least for slow VM
30389      instructions. */
30390   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30391 #endif
30392 #if defined (JITTER_PROFILE_COUNT)
30393   /* Notice that, differently from the code above, this
30394      instrumentation code *can* be reordered freely: as long as a
30395      VM instruction is counted, the count increment can be placed
30396      anyehere.  Let GCC move this code and possibly achieve better
30397      throughput by exploiting instruction-level parallelism and
30398      therefore approximate more closely a non-profiled build. */
30399   JITTER_PROFILE_COUNT_UPDATE
30400      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30401       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30402 #endif
30403 
30404 /* User-specified code, instruction-beginning-c part: beginning. */
30405 
30406 
30407 /* User-specified code, instruction-beginning-c part: end */
30408 
30409 
30410     /* User code for primitive-quotient-unsafe/fR . */
30411 
30412     /* The second argument has already been validated if we are using this. */
30413     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
30414     JITTERLISP_QUOTIENT_UNSAFE_(JITTER_TOP_MAINSTACK(),
30415                                JITTER_UNDER_TOP_MAINSTACK(),
30416                                JITTER_TOP_MAINSTACK());
30417     JITTER_NIP_MAINSTACK();
30418 
30419     /* End of the user code for primitive-quotient-unsafe/fR . */
30420 
30421 /* User-specified code, instruction-end-c part: beginning. */
30422 
30423 
30424 /* User-specified code, instruction-end-c part: end */
30425 
30426     /* Undefine the primitive-quotient-unsafe/fR argument macros so they can't be used
30427        by mistake in the instruction body coming next. */
30428 #   undef JITTER_SLOW_REGISTER_OFFSET0
30429 #   undef JITTER_ARG0
30430 #   undef JITTER_ARGN0
30431 #   undef JITTER_ARGU0
30432 #   undef JITTER_ARGP0
30433 #   undef JITTER_ARGF0
30434 
30435 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30436 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30437 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30438 
30439   }
30440  JITTER_INSTRUCTION_EPILOG_(primitive-quotient-unsafe/fR, primitive_mquotient_munsafe__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30441 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30442 
30443   JITTER_INSTRUCTION_PROLOG_(primitive-remainder/fR, primitive_mremainder__fR, hot)
30444   {
30445     /* This specialized instruction is not a replacement. */
30446 #   undef JITTER_BRANCH_FAST
30447 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30448 #   undef JITTER_BRANCH_FAST_IF_ZERO
30449 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30450 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30451 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30452 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30453 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30454 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30455 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30456 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30457 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30458 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30459 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30460 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30461 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30462 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30463 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30464 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30465 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30466 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30467 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30468 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30469 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30470 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30471 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30472 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30473 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30474 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30475 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30476 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30477 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30478 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30479 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30480 #   undef JITTER_BRANCH_FAST_IF_AND
30481 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30482 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30483 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30484 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30485 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30486 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30487 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30488 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30489 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30490 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30491 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30492 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30493 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30494 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30495 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30496 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30497 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30498 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30499 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30500 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30501 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30502 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30503 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30504 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30505 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30506 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30507 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30508 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30509 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30510 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       162
30511 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-remainder/fR
30512 
30513 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mremainder__fR
30514 
30515   /* The residual arity varies depending on whether we have fast labels. */
30516 #ifdef JITTER_HAVE_PATCH_IN
30517   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30518 #else
30519   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
30520 #endif // #ifdef JITTER_HAVE_PATCH_IN
30521 
30522   /* Define argument-access macros for primitive-remainder/fR . */
30523 #ifdef JITTER_HAVE_PATCH_IN
30524   /* Define argument-access macros assuming that fast branches are enabled. */
30525     /* The 0th argument is a "residual" fast label.  Define its
30526        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
30527        so that at replication time we know what instruction address to patch in. */
30528 #   define JITTER_ARGF0 0
30529     /* JITTER_ARG0 is intentionally not defined for a fast label. */
30530 
30531 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30532 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30533 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30534 
30535 #else
30536   /* Define argument-access macros assuming that fast branches are disabled. */
30537 #if defined(JITTER_DISPATCH_NO_THREADING)
30538 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
30539     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
30540 #elif defined (JITTER_REPLICATE)
30541 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
30542 #else
30543 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
30544 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
30545 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30546 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30547 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30548 #   define JITTER_ARGF0 JITTER_ARGP0
30549 
30550 # endif // #ifdef JITTER_HAVE_PATCH_IN
30551 
30552 #if defined (JITTER_PROFILE_SAMPLE)
30553   JITTER_PROFILE_SAMPLE_UPDATE
30554      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30555       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30556   /* Force the compiler not move sample-profiling instrumentation
30557      beyond this point; this way the actual user code is timed.
30558      This is still not perfect, as residuals are materialised before
30559      we arrive here, but should be adequate at least for slow VM
30560      instructions. */
30561   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30562 #endif
30563 #if defined (JITTER_PROFILE_COUNT)
30564   /* Notice that, differently from the code above, this
30565      instrumentation code *can* be reordered freely: as long as a
30566      VM instruction is counted, the count increment can be placed
30567      anyehere.  Let GCC move this code and possibly achieve better
30568      throughput by exploiting instruction-level parallelism and
30569      therefore approximate more closely a non-profiled build. */
30570   JITTER_PROFILE_COUNT_UPDATE
30571      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30572       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30573 #endif
30574 
30575 /* User-specified code, instruction-beginning-c part: beginning. */
30576 
30577 
30578 /* User-specified code, instruction-beginning-c part: end */
30579 
30580 
30581     /* User code for primitive-remainder/fR . */
30582 
30583     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
30584     JITTERLISP_REMAINDER_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
30585                                       JITTER_UNDER_TOP_MAINSTACK(),
30586                                       JITTER_TOP_MAINSTACK(),
30587                                       JITTER_ARGF0);
30588     JITTER_NIP_MAINSTACK();
30589 
30590     /* End of the user code for primitive-remainder/fR . */
30591 
30592 /* User-specified code, instruction-end-c part: beginning. */
30593 
30594 
30595 /* User-specified code, instruction-end-c part: end */
30596 
30597     /* Undefine the primitive-remainder/fR argument macros so they can't be used
30598        by mistake in the instruction body coming next. */
30599 #   undef JITTER_SLOW_REGISTER_OFFSET0
30600 #   undef JITTER_ARG0
30601 #   undef JITTER_ARGN0
30602 #   undef JITTER_ARGU0
30603 #   undef JITTER_ARGP0
30604 #   undef JITTER_ARGF0
30605 
30606 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30607 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30608 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30609 
30610   }
30611  JITTER_INSTRUCTION_EPILOG_(primitive-remainder/fR, primitive_mremainder__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30612 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30613 
30614   JITTER_INSTRUCTION_PROLOG_(primitive-remainder-unsafe/fR, primitive_mremainder_munsafe__fR, hot)
30615   {
30616     /* This specialized instruction is not a replacement. */
30617 #   undef JITTER_BRANCH_FAST
30618 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30619 #   undef JITTER_BRANCH_FAST_IF_ZERO
30620 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30621 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30622 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30623 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30624 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30625 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30626 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30627 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30628 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30629 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30630 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30631 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30632 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30633 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30634 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30635 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30636 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30637 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30638 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30639 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30640 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30641 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30642 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30643 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30644 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30645 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30646 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30647 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30648 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30649 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30650 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30651 #   undef JITTER_BRANCH_FAST_IF_AND
30652 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30653 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30654 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30655 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30656 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30657 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30658 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30659 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30660 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30661 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30662 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30663 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30664 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30665 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30666 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30667 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30668 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30669 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30670 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30671 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30672 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30673 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30674 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30675 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30676 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30677 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30678 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30679 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30680 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30681 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       163
30682 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-remainder-unsafe/fR
30683 
30684 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mremainder_munsafe__fR
30685 
30686   /* The residual arity varies depending on whether we have fast labels. */
30687 #ifdef JITTER_HAVE_PATCH_IN
30688   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30689 #else
30690   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
30691 #endif // #ifdef JITTER_HAVE_PATCH_IN
30692 
30693   /* Define argument-access macros for primitive-remainder-unsafe/fR . */
30694 #ifdef JITTER_HAVE_PATCH_IN
30695   /* Define argument-access macros assuming that fast branches are enabled. */
30696     /* The 0th argument is a "residual" fast label.  Define its
30697        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
30698        so that at replication time we know what instruction address to patch in. */
30699 #   define JITTER_ARGF0 0
30700     /* JITTER_ARG0 is intentionally not defined for a fast label. */
30701 
30702 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30703 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30704 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30705 
30706 #else
30707   /* Define argument-access macros assuming that fast branches are disabled. */
30708 #if defined(JITTER_DISPATCH_NO_THREADING)
30709 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
30710     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
30711 #elif defined (JITTER_REPLICATE)
30712 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
30713 #else
30714 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
30715 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
30716 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30717 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30718 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30719 #   define JITTER_ARGF0 JITTER_ARGP0
30720 
30721 # endif // #ifdef JITTER_HAVE_PATCH_IN
30722 
30723 #if defined (JITTER_PROFILE_SAMPLE)
30724   JITTER_PROFILE_SAMPLE_UPDATE
30725      (JITTERLISPVM_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      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30743       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30744 #endif
30745 
30746 /* User-specified code, instruction-beginning-c part: beginning. */
30747 
30748 
30749 /* User-specified code, instruction-beginning-c part: end */
30750 
30751 
30752     /* User code for primitive-remainder-unsafe/fR . */
30753 
30754     /* The second argument has already been validated if we are using this. */
30755     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
30756     JITTERLISP_REMAINDER_UNSAFE_(JITTER_TOP_MAINSTACK(),
30757                                  JITTER_UNDER_TOP_MAINSTACK(),
30758                                  JITTER_TOP_MAINSTACK());
30759     JITTER_NIP_MAINSTACK();
30760 
30761     /* End of the user code for primitive-remainder-unsafe/fR . */
30762 
30763 /* User-specified code, instruction-end-c part: beginning. */
30764 
30765 
30766 /* User-specified code, instruction-end-c part: end */
30767 
30768     /* Undefine the primitive-remainder-unsafe/fR argument macros so they can't be used
30769        by mistake in the instruction body coming next. */
30770 #   undef JITTER_SLOW_REGISTER_OFFSET0
30771 #   undef JITTER_ARG0
30772 #   undef JITTER_ARGN0
30773 #   undef JITTER_ARGU0
30774 #   undef JITTER_ARGP0
30775 #   undef JITTER_ARGF0
30776 
30777 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30778 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30779 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30780 
30781   }
30782  JITTER_INSTRUCTION_EPILOG_(primitive-remainder-unsafe/fR, primitive_mremainder_munsafe__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30783 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30784 
30785   JITTER_INSTRUCTION_PROLOG_(primitive-set-carb-special/fR, primitive_mset_mcarb_mspecial__fR, hot)
30786   {
30787     /* This specialized instruction is not a replacement. */
30788 #   undef JITTER_BRANCH_FAST
30789 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30790 #   undef JITTER_BRANCH_FAST_IF_ZERO
30791 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30792 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30793 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30794 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30795 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30796 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30797 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30798 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30799 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30800 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30801 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30802 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30803 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30804 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30805 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30806 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30807 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30808 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30809 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30810 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30811 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30812 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30813 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30814 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30815 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30816 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30817 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30818 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30819 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30820 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30821 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30822 #   undef JITTER_BRANCH_FAST_IF_AND
30823 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30824 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30825 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30826 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30827 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30828 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30829 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30830 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30831 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
30832 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30833 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
30834 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30835 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
30836 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30837 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
30838 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30839 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
30840 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30841 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
30842 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30843 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
30844 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30845 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
30846 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30847 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
30848 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30849 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
30850 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30851 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
30852 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       164
30853 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-set-carb-special/fR
30854 
30855 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mset_mcarb_mspecial__fR
30856 
30857   /* The residual arity varies depending on whether we have fast labels. */
30858 #ifdef JITTER_HAVE_PATCH_IN
30859   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
30860 #else
30861   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
30862 #endif // #ifdef JITTER_HAVE_PATCH_IN
30863 
30864   /* Define argument-access macros for primitive-set-carb-special/fR . */
30865 #ifdef JITTER_HAVE_PATCH_IN
30866   /* Define argument-access macros assuming that fast branches are enabled. */
30867     /* The 0th argument is a "residual" fast label.  Define its
30868        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
30869        so that at replication time we know what instruction address to patch in. */
30870 #   define JITTER_ARGF0 0
30871     /* JITTER_ARG0 is intentionally not defined for a fast label. */
30872 
30873 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30874 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30875 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30876 
30877 #else
30878   /* Define argument-access macros assuming that fast branches are disabled. */
30879 #if defined(JITTER_DISPATCH_NO_THREADING)
30880 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
30881     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
30882 #elif defined (JITTER_REPLICATE)
30883 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
30884 #else
30885 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
30886 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
30887 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
30888 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
30889 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
30890 #   define JITTER_ARGF0 JITTER_ARGP0
30891 
30892 # endif // #ifdef JITTER_HAVE_PATCH_IN
30893 
30894 #if defined (JITTER_PROFILE_SAMPLE)
30895   JITTER_PROFILE_SAMPLE_UPDATE
30896      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30897       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30898   /* Force the compiler not move sample-profiling instrumentation
30899      beyond this point; this way the actual user code is timed.
30900      This is still not perfect, as residuals are materialised before
30901      we arrive here, but should be adequate at least for slow VM
30902      instructions. */
30903   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
30904 #endif
30905 #if defined (JITTER_PROFILE_COUNT)
30906   /* Notice that, differently from the code above, this
30907      instrumentation code *can* be reordered freely: as long as a
30908      VM instruction is counted, the count increment can be placed
30909      anyehere.  Let GCC move this code and possibly achieve better
30910      throughput by exploiting instruction-level parallelism and
30911      therefore approximate more closely a non-profiled build. */
30912   JITTER_PROFILE_COUNT_UPDATE
30913      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
30914       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
30915 #endif
30916 
30917 /* User-specified code, instruction-beginning-c part: beginning. */
30918 
30919 
30920 /* User-specified code, instruction-beginning-c part: end */
30921 
30922 
30923     /* User code for primitive-set-carb-special/fR . */
30924 
30925     JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
30926     jitterlisp_object useless __attribute__ ((unused));
30927     JITTERLISP_SET_CARB_(useless,
30928                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
30929     /* Leave the two operands on the stack. */
30930 
30931     /* End of the user code for primitive-set-carb-special/fR . */
30932 
30933 /* User-specified code, instruction-end-c part: beginning. */
30934 
30935 
30936 /* User-specified code, instruction-end-c part: end */
30937 
30938     /* Undefine the primitive-set-carb-special/fR argument macros so they can't be used
30939        by mistake in the instruction body coming next. */
30940 #   undef JITTER_SLOW_REGISTER_OFFSET0
30941 #   undef JITTER_ARG0
30942 #   undef JITTER_ARGN0
30943 #   undef JITTER_ARGU0
30944 #   undef JITTER_ARGP0
30945 #   undef JITTER_ARGF0
30946 
30947 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
30948 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
30949 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
30950 
30951   }
30952  JITTER_INSTRUCTION_EPILOG_(primitive-set-carb-special/fR, primitive_mset_mcarb_mspecial__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
30953 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
30954 
30955   JITTER_INSTRUCTION_PROLOG_(primitive-set-cdrb-special/fR, primitive_mset_mcdrb_mspecial__fR, hot)
30956   {
30957     /* This specialized instruction is not a replacement. */
30958 #   undef JITTER_BRANCH_FAST
30959 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
30960 #   undef JITTER_BRANCH_FAST_IF_ZERO
30961 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
30962 #   undef JITTER_BRANCH_FAST_IF_NONZERO
30963 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
30964 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
30965 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
30966 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
30967 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
30968 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
30969 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
30970 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
30971 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
30972 #   undef JITTER_BRANCH_FAST_IF_EQUAL
30973 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
30974 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
30975 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
30976 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
30977 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
30978 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30979 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
30980 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30981 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
30982 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30983 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
30984 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30985 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
30986 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30987 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
30988 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30989 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
30990 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30991 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
30992 #   undef JITTER_BRANCH_FAST_IF_AND
30993 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
30994 #   undef JITTER_BRANCH_FAST_IF_NOTAND
30995 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
30996 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30997 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
30998 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
30999 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31000 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31001 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31002 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31003 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31004 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31005 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31006 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31007 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31008 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31009 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31010 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31011 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31012 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31013 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31014 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31015 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31016 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31017 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31018 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31019 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31020 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31021 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31022 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       165
31023 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-set-cdrb-special/fR
31024 
31025 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mset_mcdrb_mspecial__fR
31026 
31027   /* The residual arity varies depending on whether we have fast labels. */
31028 #ifdef JITTER_HAVE_PATCH_IN
31029   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31030 #else
31031   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
31032 #endif // #ifdef JITTER_HAVE_PATCH_IN
31033 
31034   /* Define argument-access macros for primitive-set-cdrb-special/fR . */
31035 #ifdef JITTER_HAVE_PATCH_IN
31036   /* Define argument-access macros assuming that fast branches are enabled. */
31037     /* The 0th argument is a "residual" fast label.  Define its
31038        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
31039        so that at replication time we know what instruction address to patch in. */
31040 #   define JITTER_ARGF0 0
31041     /* JITTER_ARG0 is intentionally not defined for a fast label. */
31042 
31043 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31044 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31045 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31046 
31047 #else
31048   /* Define argument-access macros assuming that fast branches are disabled. */
31049 #if defined(JITTER_DISPATCH_NO_THREADING)
31050 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
31051     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
31052 #elif defined (JITTER_REPLICATE)
31053 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
31054 #else
31055 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
31056 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31057 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31058 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31059 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31060 #   define JITTER_ARGF0 JITTER_ARGP0
31061 
31062 # endif // #ifdef JITTER_HAVE_PATCH_IN
31063 
31064 #if defined (JITTER_PROFILE_SAMPLE)
31065   JITTER_PROFILE_SAMPLE_UPDATE
31066      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31067       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31068   /* Force the compiler not move sample-profiling instrumentation
31069      beyond this point; this way the actual user code is timed.
31070      This is still not perfect, as residuals are materialised before
31071      we arrive here, but should be adequate at least for slow VM
31072      instructions. */
31073   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31074 #endif
31075 #if defined (JITTER_PROFILE_COUNT)
31076   /* Notice that, differently from the code above, this
31077      instrumentation code *can* be reordered freely: as long as a
31078      VM instruction is counted, the count increment can be placed
31079      anyehere.  Let GCC move this code and possibly achieve better
31080      throughput by exploiting instruction-level parallelism and
31081      therefore approximate more closely a non-profiled build. */
31082   JITTER_PROFILE_COUNT_UPDATE
31083      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31084       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31085 #endif
31086 
31087 /* User-specified code, instruction-beginning-c part: beginning. */
31088 
31089 
31090 /* User-specified code, instruction-beginning-c part: end */
31091 
31092 
31093     /* User code for primitive-set-cdrb-special/fR . */
31094 
31095     JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
31096     jitterlisp_object useless __attribute__ ((unused));
31097     JITTERLISP_SET_CDRB_(useless,
31098                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
31099     /* Leave the two operands on the stack. */
31100 
31101     /* End of the user code for primitive-set-cdrb-special/fR . */
31102 
31103 /* User-specified code, instruction-end-c part: beginning. */
31104 
31105 
31106 /* User-specified code, instruction-end-c part: end */
31107 
31108     /* Undefine the primitive-set-cdrb-special/fR argument macros so they can't be used
31109        by mistake in the instruction body coming next. */
31110 #   undef JITTER_SLOW_REGISTER_OFFSET0
31111 #   undef JITTER_ARG0
31112 #   undef JITTER_ARGN0
31113 #   undef JITTER_ARGU0
31114 #   undef JITTER_ARGP0
31115 #   undef JITTER_ARGF0
31116 
31117 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31118 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31119 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31120 
31121   }
31122  JITTER_INSTRUCTION_EPILOG_(primitive-set-cdrb-special/fR, primitive_mset_mcdrb_mspecial__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31123 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31124 
31125   JITTER_INSTRUCTION_PROLOG_(primitive-symbolp, primitive_msymbolp, hot)
31126   {
31127     /* This specialized instruction is not a replacement. */
31128 #   undef JITTER_BRANCH_FAST
31129 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31130 #   undef JITTER_BRANCH_FAST_IF_ZERO
31131 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31132 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31133 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31134 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31135 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31136 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31137 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31138 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31139 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31140 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31141 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31142 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31143 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31144 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31145 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31146 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31147 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31148 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31149 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31150 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31151 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31152 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31153 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31154 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31155 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31156 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31157 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31158 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31159 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31160 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31161 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31162 #   undef JITTER_BRANCH_FAST_IF_AND
31163 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31164 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31165 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31166 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31167 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31168 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31169 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31170 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31171 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31172 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31173 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31174 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31175 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31176 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31177 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31178 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31179 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31180 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31181 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31182 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31183 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31184 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31185 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31186 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31187 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31188 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31189 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31190 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31191 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31192 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       166
31193 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-symbolp
31194 
31195 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_msymbolp
31196 
31197   /* The residual arity for this instruction does not depend on fast labels. */
31198   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31199 
31200 
31201 #if defined (JITTER_PROFILE_SAMPLE)
31202   JITTER_PROFILE_SAMPLE_UPDATE
31203      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31204       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31205   /* Force the compiler not move sample-profiling instrumentation
31206      beyond this point; this way the actual user code is timed.
31207      This is still not perfect, as residuals are materialised before
31208      we arrive here, but should be adequate at least for slow VM
31209      instructions. */
31210   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31211 #endif
31212 #if defined (JITTER_PROFILE_COUNT)
31213   /* Notice that, differently from the code above, this
31214      instrumentation code *can* be reordered freely: as long as a
31215      VM instruction is counted, the count increment can be placed
31216      anyehere.  Let GCC move this code and possibly achieve better
31217      throughput by exploiting instruction-level parallelism and
31218      therefore approximate more closely a non-profiled build. */
31219   JITTER_PROFILE_COUNT_UPDATE
31220      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31221       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31222 #endif
31223 
31224 /* User-specified code, instruction-beginning-c part: beginning. */
31225 
31226 
31227 /* User-specified code, instruction-beginning-c part: end */
31228 
31229 
31230     /* User code for primitive-symbolp . */
31231 
31232     JITTERLISP_SYMBOLP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
31233 
31234     /* End of the user code for primitive-symbolp . */
31235 
31236 /* User-specified code, instruction-end-c part: beginning. */
31237 
31238 
31239 /* User-specified code, instruction-end-c part: end */
31240 
31241     /* Undefine the primitive-symbolp argument macros so they can't be used
31242        by mistake in the instruction body coming next. */
31243 
31244 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31245 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31246 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31247 
31248   }
31249  JITTER_INSTRUCTION_EPILOG_(primitive-symbolp, primitive_msymbolp, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31250 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31251 
31252   JITTER_INSTRUCTION_PROLOG_(primitive-two-divided/fR, primitive_mtwo_mdivided__fR, hot)
31253   {
31254     /* This specialized instruction is not a replacement. */
31255 #   undef JITTER_BRANCH_FAST
31256 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31257 #   undef JITTER_BRANCH_FAST_IF_ZERO
31258 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31259 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31260 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31261 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31262 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31263 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31264 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31265 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31266 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31267 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31268 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31269 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31270 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31271 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31272 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31273 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31274 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31275 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31276 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31277 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31278 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31279 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31280 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31281 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31282 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31283 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31284 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31285 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31286 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31287 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31288 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31289 #   undef JITTER_BRANCH_FAST_IF_AND
31290 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31291 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31292 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31293 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31294 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31295 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31296 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31297 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31298 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31299 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31300 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31301 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31302 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31303 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31304 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31305 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31306 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31307 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31308 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31309 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31310 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31311 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31312 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31313 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31314 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31315 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31316 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31317 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31318 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31319 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       167
31320 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-divided/fR
31321 
31322 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mdivided__fR
31323 
31324   /* The residual arity varies depending on whether we have fast labels. */
31325 #ifdef JITTER_HAVE_PATCH_IN
31326   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31327 #else
31328   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
31329 #endif // #ifdef JITTER_HAVE_PATCH_IN
31330 
31331   /* Define argument-access macros for primitive-two-divided/fR . */
31332 #ifdef JITTER_HAVE_PATCH_IN
31333   /* Define argument-access macros assuming that fast branches are enabled. */
31334     /* The 0th argument is a "residual" fast label.  Define its
31335        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
31336        so that at replication time we know what instruction address to patch in. */
31337 #   define JITTER_ARGF0 0
31338     /* JITTER_ARG0 is intentionally not defined for a fast label. */
31339 
31340 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31341 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31342 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31343 
31344 #else
31345   /* Define argument-access macros assuming that fast branches are disabled. */
31346 #if defined(JITTER_DISPATCH_NO_THREADING)
31347 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
31348     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
31349 #elif defined (JITTER_REPLICATE)
31350 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
31351 #else
31352 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
31353 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31354 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31355 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31356 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31357 #   define JITTER_ARGF0 JITTER_ARGP0
31358 
31359 # endif // #ifdef JITTER_HAVE_PATCH_IN
31360 
31361 #if defined (JITTER_PROFILE_SAMPLE)
31362   JITTER_PROFILE_SAMPLE_UPDATE
31363      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31364       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31365   /* Force the compiler not move sample-profiling instrumentation
31366      beyond this point; this way the actual user code is timed.
31367      This is still not perfect, as residuals are materialised before
31368      we arrive here, but should be adequate at least for slow VM
31369      instructions. */
31370   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31371 #endif
31372 #if defined (JITTER_PROFILE_COUNT)
31373   /* Notice that, differently from the code above, this
31374      instrumentation code *can* be reordered freely: as long as a
31375      VM instruction is counted, the count increment can be placed
31376      anyehere.  Let GCC move this code and possibly achieve better
31377      throughput by exploiting instruction-level parallelism and
31378      therefore approximate more closely a non-profiled build. */
31379   JITTER_PROFILE_COUNT_UPDATE
31380      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31381       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31382 #endif
31383 
31384 /* User-specified code, instruction-beginning-c part: beginning. */
31385 
31386 
31387 /* User-specified code, instruction-beginning-c part: end */
31388 
31389 
31390     /* User code for primitive-two-divided/fR . */
31391 
31392     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
31393     JITTERLISP_2DIVIDED_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
31394 
31395     /* End of the user code for primitive-two-divided/fR . */
31396 
31397 /* User-specified code, instruction-end-c part: beginning. */
31398 
31399 
31400 /* User-specified code, instruction-end-c part: end */
31401 
31402     /* Undefine the primitive-two-divided/fR argument macros so they can't be used
31403        by mistake in the instruction body coming next. */
31404 #   undef JITTER_SLOW_REGISTER_OFFSET0
31405 #   undef JITTER_ARG0
31406 #   undef JITTER_ARGN0
31407 #   undef JITTER_ARGU0
31408 #   undef JITTER_ARGP0
31409 #   undef JITTER_ARGF0
31410 
31411 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31412 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31413 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31414 
31415   }
31416  JITTER_INSTRUCTION_EPILOG_(primitive-two-divided/fR, primitive_mtwo_mdivided__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31417 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31418 
31419   JITTER_INSTRUCTION_PROLOG_(primitive-two-quotient/fR, primitive_mtwo_mquotient__fR, hot)
31420   {
31421     /* This specialized instruction is not a replacement. */
31422 #   undef JITTER_BRANCH_FAST
31423 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31424 #   undef JITTER_BRANCH_FAST_IF_ZERO
31425 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31426 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31427 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31428 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31429 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31430 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31431 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31432 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31433 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31434 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31435 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31436 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31437 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31438 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31439 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31440 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31441 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31442 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31443 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31444 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31445 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31446 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31447 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31448 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31449 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31450 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31451 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31452 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31453 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31454 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31455 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31456 #   undef JITTER_BRANCH_FAST_IF_AND
31457 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31458 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31459 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31460 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31461 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31462 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31463 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31464 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31465 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31466 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31467 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31468 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31469 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31470 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31471 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31472 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31473 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31474 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31475 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31476 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31477 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31478 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31479 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31480 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31481 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31482 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31483 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31484 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31485 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31486 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       168
31487 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-quotient/fR
31488 
31489 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mquotient__fR
31490 
31491   /* The residual arity varies depending on whether we have fast labels. */
31492 #ifdef JITTER_HAVE_PATCH_IN
31493   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31494 #else
31495   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
31496 #endif // #ifdef JITTER_HAVE_PATCH_IN
31497 
31498   /* Define argument-access macros for primitive-two-quotient/fR . */
31499 #ifdef JITTER_HAVE_PATCH_IN
31500   /* Define argument-access macros assuming that fast branches are enabled. */
31501     /* The 0th argument is a "residual" fast label.  Define its
31502        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
31503        so that at replication time we know what instruction address to patch in. */
31504 #   define JITTER_ARGF0 0
31505     /* JITTER_ARG0 is intentionally not defined for a fast label. */
31506 
31507 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31508 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31509 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31510 
31511 #else
31512   /* Define argument-access macros assuming that fast branches are disabled. */
31513 #if defined(JITTER_DISPATCH_NO_THREADING)
31514 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
31515     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
31516 #elif defined (JITTER_REPLICATE)
31517 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
31518 #else
31519 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
31520 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31521 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31522 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31523 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31524 #   define JITTER_ARGF0 JITTER_ARGP0
31525 
31526 # endif // #ifdef JITTER_HAVE_PATCH_IN
31527 
31528 #if defined (JITTER_PROFILE_SAMPLE)
31529   JITTER_PROFILE_SAMPLE_UPDATE
31530      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31531       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31532   /* Force the compiler not move sample-profiling instrumentation
31533      beyond this point; this way the actual user code is timed.
31534      This is still not perfect, as residuals are materialised before
31535      we arrive here, but should be adequate at least for slow VM
31536      instructions. */
31537   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31538 #endif
31539 #if defined (JITTER_PROFILE_COUNT)
31540   /* Notice that, differently from the code above, this
31541      instrumentation code *can* be reordered freely: as long as a
31542      VM instruction is counted, the count increment can be placed
31543      anyehere.  Let GCC move this code and possibly achieve better
31544      throughput by exploiting instruction-level parallelism and
31545      therefore approximate more closely a non-profiled build. */
31546   JITTER_PROFILE_COUNT_UPDATE
31547      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31548       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31549 #endif
31550 
31551 /* User-specified code, instruction-beginning-c part: beginning. */
31552 
31553 
31554 /* User-specified code, instruction-beginning-c part: end */
31555 
31556 
31557     /* User code for primitive-two-quotient/fR . */
31558 
31559     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
31560     JITTERLISP_2QUOTIENT_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
31561 
31562     /* End of the user code for primitive-two-quotient/fR . */
31563 
31564 /* User-specified code, instruction-end-c part: beginning. */
31565 
31566 
31567 /* User-specified code, instruction-end-c part: end */
31568 
31569     /* Undefine the primitive-two-quotient/fR argument macros so they can't be used
31570        by mistake in the instruction body coming next. */
31571 #   undef JITTER_SLOW_REGISTER_OFFSET0
31572 #   undef JITTER_ARG0
31573 #   undef JITTER_ARGN0
31574 #   undef JITTER_ARGU0
31575 #   undef JITTER_ARGP0
31576 #   undef JITTER_ARGF0
31577 
31578 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31579 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31580 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31581 
31582   }
31583  JITTER_INSTRUCTION_EPILOG_(primitive-two-quotient/fR, primitive_mtwo_mquotient__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31584 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31585 
31586   JITTER_INSTRUCTION_PROLOG_(primitive-two-remainder/fR, primitive_mtwo_mremainder__fR, hot)
31587   {
31588     /* This specialized instruction is not a replacement. */
31589 #   undef JITTER_BRANCH_FAST
31590 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31591 #   undef JITTER_BRANCH_FAST_IF_ZERO
31592 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31593 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31594 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31595 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31596 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31597 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31598 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31599 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31600 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31601 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31602 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31603 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31604 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31605 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31606 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31607 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31608 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31609 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31610 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31611 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31612 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31613 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31614 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31615 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31616 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31617 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31618 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31619 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31620 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31621 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31622 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31623 #   undef JITTER_BRANCH_FAST_IF_AND
31624 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31625 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31626 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31627 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31628 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31629 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31630 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31631 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31632 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31633 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31634 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31635 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31636 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31637 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31638 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31639 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31640 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31641 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31642 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31643 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31644 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31645 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31646 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31647 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31648 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31649 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31650 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31651 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31652 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31653 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       169
31654 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-remainder/fR
31655 
31656 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mremainder__fR
31657 
31658   /* The residual arity varies depending on whether we have fast labels. */
31659 #ifdef JITTER_HAVE_PATCH_IN
31660   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31661 #else
31662   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
31663 #endif // #ifdef JITTER_HAVE_PATCH_IN
31664 
31665   /* Define argument-access macros for primitive-two-remainder/fR . */
31666 #ifdef JITTER_HAVE_PATCH_IN
31667   /* Define argument-access macros assuming that fast branches are enabled. */
31668     /* The 0th argument is a "residual" fast label.  Define its
31669        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
31670        so that at replication time we know what instruction address to patch in. */
31671 #   define JITTER_ARGF0 0
31672     /* JITTER_ARG0 is intentionally not defined for a fast label. */
31673 
31674 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31675 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31676 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31677 
31678 #else
31679   /* Define argument-access macros assuming that fast branches are disabled. */
31680 #if defined(JITTER_DISPATCH_NO_THREADING)
31681 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
31682     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
31683 #elif defined (JITTER_REPLICATE)
31684 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
31685 #else
31686 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
31687 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31688 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31689 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31690 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31691 #   define JITTER_ARGF0 JITTER_ARGP0
31692 
31693 # endif // #ifdef JITTER_HAVE_PATCH_IN
31694 
31695 #if defined (JITTER_PROFILE_SAMPLE)
31696   JITTER_PROFILE_SAMPLE_UPDATE
31697      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31698       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31699   /* Force the compiler not move sample-profiling instrumentation
31700      beyond this point; this way the actual user code is timed.
31701      This is still not perfect, as residuals are materialised before
31702      we arrive here, but should be adequate at least for slow VM
31703      instructions. */
31704   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31705 #endif
31706 #if defined (JITTER_PROFILE_COUNT)
31707   /* Notice that, differently from the code above, this
31708      instrumentation code *can* be reordered freely: as long as a
31709      VM instruction is counted, the count increment can be placed
31710      anyehere.  Let GCC move this code and possibly achieve better
31711      throughput by exploiting instruction-level parallelism and
31712      therefore approximate more closely a non-profiled build. */
31713   JITTER_PROFILE_COUNT_UPDATE
31714      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31715       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31716 #endif
31717 
31718 /* User-specified code, instruction-beginning-c part: beginning. */
31719 
31720 
31721 /* User-specified code, instruction-beginning-c part: end */
31722 
31723 
31724     /* User code for primitive-two-remainder/fR . */
31725 
31726     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
31727     JITTERLISP_2REMAINDER_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
31728 
31729     /* End of the user code for primitive-two-remainder/fR . */
31730 
31731 /* User-specified code, instruction-end-c part: beginning. */
31732 
31733 
31734 /* User-specified code, instruction-end-c part: end */
31735 
31736     /* Undefine the primitive-two-remainder/fR argument macros so they can't be used
31737        by mistake in the instruction body coming next. */
31738 #   undef JITTER_SLOW_REGISTER_OFFSET0
31739 #   undef JITTER_ARG0
31740 #   undef JITTER_ARGN0
31741 #   undef JITTER_ARGU0
31742 #   undef JITTER_ARGP0
31743 #   undef JITTER_ARGF0
31744 
31745 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31746 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31747 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31748 
31749   }
31750  JITTER_INSTRUCTION_EPILOG_(primitive-two-remainder/fR, primitive_mtwo_mremainder__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31751 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31752 
31753   JITTER_INSTRUCTION_PROLOG_(primitive-two-times/fR, primitive_mtwo_mtimes__fR, hot)
31754   {
31755     /* This specialized instruction is not a replacement. */
31756 #   undef JITTER_BRANCH_FAST
31757 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31758 #   undef JITTER_BRANCH_FAST_IF_ZERO
31759 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31760 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31761 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31762 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31763 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31764 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31765 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31766 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31767 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31768 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31769 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31770 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31771 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31772 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31773 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31774 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31775 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31776 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31777 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31778 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31779 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31780 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31781 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31782 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31783 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31784 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31785 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31786 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31787 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31788 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31789 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31790 #   undef JITTER_BRANCH_FAST_IF_AND
31791 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31792 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31793 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31794 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31795 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31796 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31797 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31798 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31799 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31800 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31801 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31802 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31803 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31804 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31805 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31806 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31807 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31808 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31809 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31810 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31811 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31812 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31813 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31814 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31815 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31816 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31817 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31818 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31819 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31820 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       170
31821 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-two-times/fR
31822 
31823 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mtwo_mtimes__fR
31824 
31825   /* The residual arity varies depending on whether we have fast labels. */
31826 #ifdef JITTER_HAVE_PATCH_IN
31827   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31828 #else
31829   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
31830 #endif // #ifdef JITTER_HAVE_PATCH_IN
31831 
31832   /* Define argument-access macros for primitive-two-times/fR . */
31833 #ifdef JITTER_HAVE_PATCH_IN
31834   /* Define argument-access macros assuming that fast branches are enabled. */
31835     /* The 0th argument is a "residual" fast label.  Define its
31836        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
31837        so that at replication time we know what instruction address to patch in. */
31838 #   define JITTER_ARGF0 0
31839     /* JITTER_ARG0 is intentionally not defined for a fast label. */
31840 
31841 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31842 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31843 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31844 
31845 #else
31846   /* Define argument-access macros assuming that fast branches are disabled. */
31847 #if defined(JITTER_DISPATCH_NO_THREADING)
31848 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
31849     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
31850 #elif defined (JITTER_REPLICATE)
31851 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
31852 #else
31853 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
31854 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
31855 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
31856 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
31857 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
31858 #   define JITTER_ARGF0 JITTER_ARGP0
31859 
31860 # endif // #ifdef JITTER_HAVE_PATCH_IN
31861 
31862 #if defined (JITTER_PROFILE_SAMPLE)
31863   JITTER_PROFILE_SAMPLE_UPDATE
31864      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31865       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31866   /* Force the compiler not move sample-profiling instrumentation
31867      beyond this point; this way the actual user code is timed.
31868      This is still not perfect, as residuals are materialised before
31869      we arrive here, but should be adequate at least for slow VM
31870      instructions. */
31871   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
31872 #endif
31873 #if defined (JITTER_PROFILE_COUNT)
31874   /* Notice that, differently from the code above, this
31875      instrumentation code *can* be reordered freely: as long as a
31876      VM instruction is counted, the count increment can be placed
31877      anyehere.  Let GCC move this code and possibly achieve better
31878      throughput by exploiting instruction-level parallelism and
31879      therefore approximate more closely a non-profiled build. */
31880   JITTER_PROFILE_COUNT_UPDATE
31881      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
31882       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
31883 #endif
31884 
31885 /* User-specified code, instruction-beginning-c part: beginning. */
31886 
31887 
31888 /* User-specified code, instruction-beginning-c part: end */
31889 
31890 
31891     /* User code for primitive-two-times/fR . */
31892 
31893     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
31894     JITTERLISP_2TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
31895                                    JITTER_TOP_MAINSTACK(),
31896                                    JITTER_ARGF0);
31897 
31898     /* End of the user code for primitive-two-times/fR . */
31899 
31900 /* User-specified code, instruction-end-c part: beginning. */
31901 
31902 
31903 /* User-specified code, instruction-end-c part: end */
31904 
31905     /* Undefine the primitive-two-times/fR argument macros so they can't be used
31906        by mistake in the instruction body coming next. */
31907 #   undef JITTER_SLOW_REGISTER_OFFSET0
31908 #   undef JITTER_ARG0
31909 #   undef JITTER_ARGN0
31910 #   undef JITTER_ARGU0
31911 #   undef JITTER_ARGP0
31912 #   undef JITTER_ARGF0
31913 
31914 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
31915 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
31916 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
31917 
31918   }
31919  JITTER_INSTRUCTION_EPILOG_(primitive-two-times/fR, primitive_mtwo_mtimes__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
31920 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
31921 
31922   JITTER_INSTRUCTION_PROLOG_(primitive-uniquep, primitive_muniquep, hot)
31923   {
31924     /* This specialized instruction is not a replacement. */
31925 #   undef JITTER_BRANCH_FAST
31926 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
31927 #   undef JITTER_BRANCH_FAST_IF_ZERO
31928 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
31929 #   undef JITTER_BRANCH_FAST_IF_NONZERO
31930 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
31931 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
31932 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
31933 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
31934 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
31935 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
31936 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
31937 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
31938 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
31939 #   undef JITTER_BRANCH_FAST_IF_EQUAL
31940 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
31941 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
31942 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
31943 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
31944 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
31945 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31946 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
31947 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31948 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
31949 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31950 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
31951 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31952 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
31953 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31954 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
31955 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31956 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
31957 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31958 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
31959 #   undef JITTER_BRANCH_FAST_IF_AND
31960 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
31961 #   undef JITTER_BRANCH_FAST_IF_NOTAND
31962 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
31963 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31964 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
31965 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31966 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
31967 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31968 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
31969 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31970 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
31971 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31972 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
31973 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31974 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
31975 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31976 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
31977 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31978 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
31979 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31980 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
31981 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31982 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
31983 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31984 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
31985 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31986 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
31987 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31988 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
31989 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       171
31990 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-uniquep
31991 
31992 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_muniquep
31993 
31994   /* The residual arity for this instruction does not depend on fast labels. */
31995   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
31996 
31997 
31998 #if defined (JITTER_PROFILE_SAMPLE)
31999   JITTER_PROFILE_SAMPLE_UPDATE
32000      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32001       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32002   /* Force the compiler not move sample-profiling instrumentation
32003      beyond this point; this way the actual user code is timed.
32004      This is still not perfect, as residuals are materialised before
32005      we arrive here, but should be adequate at least for slow VM
32006      instructions. */
32007   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32008 #endif
32009 #if defined (JITTER_PROFILE_COUNT)
32010   /* Notice that, differently from the code above, this
32011      instrumentation code *can* be reordered freely: as long as a
32012      VM instruction is counted, the count increment can be placed
32013      anyehere.  Let GCC move this code and possibly achieve better
32014      throughput by exploiting instruction-level parallelism and
32015      therefore approximate more closely a non-profiled build. */
32016   JITTER_PROFILE_COUNT_UPDATE
32017      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32018       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32019 #endif
32020 
32021 /* User-specified code, instruction-beginning-c part: beginning. */
32022 
32023 
32024 /* User-specified code, instruction-beginning-c part: end */
32025 
32026 
32027     /* User code for primitive-uniquep . */
32028 
32029     JITTERLISP_UNIQUEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
32030 
32031     /* End of the user code for primitive-uniquep . */
32032 
32033 /* User-specified code, instruction-end-c part: beginning. */
32034 
32035 
32036 /* User-specified code, instruction-end-c part: end */
32037 
32038     /* Undefine the primitive-uniquep argument macros so they can't be used
32039        by mistake in the instruction body coming next. */
32040 
32041 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32042 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32043 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32044 
32045   }
32046  JITTER_INSTRUCTION_EPILOG_(primitive-uniquep, primitive_muniquep, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32047 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32048 
32049   JITTER_INSTRUCTION_PROLOG_(primitive-zerop/fR, primitive_mzerop__fR, hot)
32050   {
32051     /* This specialized instruction is not a replacement. */
32052 #   undef JITTER_BRANCH_FAST
32053 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32054 #   undef JITTER_BRANCH_FAST_IF_ZERO
32055 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32056 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32057 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32058 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32059 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32060 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32061 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32062 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32063 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32064 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32065 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32066 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32067 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32068 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32069 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32070 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32071 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32072 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32073 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32074 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32075 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32076 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32077 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32078 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32079 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32080 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32081 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32082 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32083 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32084 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32085 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32086 #   undef JITTER_BRANCH_FAST_IF_AND
32087 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32088 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32089 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32090 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32091 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32092 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32093 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32094 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32095 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32096 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32097 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32098 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32099 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32100 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32101 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32102 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32103 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32104 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32105 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32106 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32107 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32108 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32109 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32110 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32111 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32112 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32113 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32114 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32115 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32116 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       172
32117 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         primitive-zerop/fR
32118 
32119 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME primitive_mzerop__fR
32120 
32121   /* The residual arity varies depending on whether we have fast labels. */
32122 #ifdef JITTER_HAVE_PATCH_IN
32123   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32124 #else
32125   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
32126 #endif // #ifdef JITTER_HAVE_PATCH_IN
32127 
32128   /* Define argument-access macros for primitive-zerop/fR . */
32129 #ifdef JITTER_HAVE_PATCH_IN
32130   /* Define argument-access macros assuming that fast branches are enabled. */
32131     /* The 0th argument is a "residual" fast label.  Define its
32132        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
32133        so that at replication time we know what instruction address to patch in. */
32134 #   define JITTER_ARGF0 0
32135     /* JITTER_ARG0 is intentionally not defined for a fast label. */
32136 
32137 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32138 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32139 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32140 
32141 #else
32142   /* Define argument-access macros assuming that fast branches are disabled. */
32143 #if defined(JITTER_DISPATCH_NO_THREADING)
32144 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
32145     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
32146 #elif defined (JITTER_REPLICATE)
32147 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
32148 #else
32149 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
32150 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32151 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32152 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32153 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32154 #   define JITTER_ARGF0 JITTER_ARGP0
32155 
32156 # endif // #ifdef JITTER_HAVE_PATCH_IN
32157 
32158 #if defined (JITTER_PROFILE_SAMPLE)
32159   JITTER_PROFILE_SAMPLE_UPDATE
32160      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32161       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32162   /* Force the compiler not move sample-profiling instrumentation
32163      beyond this point; this way the actual user code is timed.
32164      This is still not perfect, as residuals are materialised before
32165      we arrive here, but should be adequate at least for slow VM
32166      instructions. */
32167   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32168 #endif
32169 #if defined (JITTER_PROFILE_COUNT)
32170   /* Notice that, differently from the code above, this
32171      instrumentation code *can* be reordered freely: as long as a
32172      VM instruction is counted, the count increment can be placed
32173      anyehere.  Let GCC move this code and possibly achieve better
32174      throughput by exploiting instruction-level parallelism and
32175      therefore approximate more closely a non-profiled build. */
32176   JITTER_PROFILE_COUNT_UPDATE
32177      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32178       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32179 #endif
32180 
32181 /* User-specified code, instruction-beginning-c part: beginning. */
32182 
32183 
32184 /* User-specified code, instruction-beginning-c part: end */
32185 
32186 
32187     /* User code for primitive-zerop/fR . */
32188 
32189     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
32190     JITTERLISP_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
32191 
32192     /* End of the user code for primitive-zerop/fR . */
32193 
32194 /* User-specified code, instruction-end-c part: beginning. */
32195 
32196 
32197 /* User-specified code, instruction-end-c part: end */
32198 
32199     /* Undefine the primitive-zerop/fR argument macros so they can't be used
32200        by mistake in the instruction body coming next. */
32201 #   undef JITTER_SLOW_REGISTER_OFFSET0
32202 #   undef JITTER_ARG0
32203 #   undef JITTER_ARGN0
32204 #   undef JITTER_ARGU0
32205 #   undef JITTER_ARGP0
32206 #   undef JITTER_ARGF0
32207 
32208 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32209 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32210 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32211 
32212   }
32213  JITTER_INSTRUCTION_EPILOG_(primitive-zerop/fR, primitive_mzerop__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32214 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32215 
32216   JITTER_INSTRUCTION_PROLOG_(procedure-prolog, procedure_mprolog, hot)
32217   {
32218     /* This specialized instruction is not a replacement. */
32219 #   undef JITTER_BRANCH_FAST
32220 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32221 #   undef JITTER_BRANCH_FAST_IF_ZERO
32222 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32223 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32224 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32225 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32226 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32227 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32228 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32229 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32230 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32231 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32232 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32233 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32234 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32235 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32236 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32237 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32238 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32239 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32240 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32241 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32242 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32243 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32244 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32245 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32246 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32247 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32248 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32249 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32250 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32251 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32252 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32253 #   undef JITTER_BRANCH_FAST_IF_AND
32254 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32255 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32256 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32257 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32258 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32259 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32260 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32261 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32262 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32263 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32264 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32265 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32266 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32267 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32268 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32269 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32270 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32271 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32272 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32273 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32274 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32275 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32276 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32277 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32278 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32279 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32280 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32281 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32282 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32283 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       173
32284 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         procedure-prolog
32285 
32286 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME procedure_mprolog
32287 
32288   /* The residual arity for this instruction does not depend on fast labels. */
32289   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32290 
32291 
32292   /* This specialized instruction is a callee.  Set the link
32293      pointer if needed... */
32294   union jitter_word _jitter_the_link;
32295   _JITTER_PROCEDURE_PROLOG (_jitter_the_link);
32296   /* ...And make it accessible to this instruction, read-only,
32297      through a macro. */
32298   #define JITTER_LINK \
32299     ((const void *) \
32300      (_jitter_the_link.pointer))
32301 
32302 #if defined (JITTER_PROFILE_SAMPLE)
32303   JITTER_PROFILE_SAMPLE_UPDATE
32304      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32305       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32306   /* Force the compiler not move sample-profiling instrumentation
32307      beyond this point; this way the actual user code is timed.
32308      This is still not perfect, as residuals are materialised before
32309      we arrive here, but should be adequate at least for slow VM
32310      instructions. */
32311   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32312 #endif
32313 #if defined (JITTER_PROFILE_COUNT)
32314   /* Notice that, differently from the code above, this
32315      instrumentation code *can* be reordered freely: as long as a
32316      VM instruction is counted, the count increment can be placed
32317      anyehere.  Let GCC move this code and possibly achieve better
32318      throughput by exploiting instruction-level parallelism and
32319      therefore approximate more closely a non-profiled build. */
32320   JITTER_PROFILE_COUNT_UPDATE
32321      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32322       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32323 #endif
32324 
32325 /* User-specified code, instruction-beginning-c part: beginning. */
32326 
32327 
32328 /* User-specified code, instruction-beginning-c part: end */
32329 
32330 
32331     /* User code for procedure-prolog . */
32332 
32333     /* Fill the return stack slot with the return address.  The return
32334        stack has already been pushed (with an unspecified value on the
32335        top) by the caller. */
32336     JITTER_TOP_RETURNSTACK() = (jitterlisp_object) JITTER_LINK;
32337     //dump_stacks (0, the_jitter_state_runtime_pointer);
32338 
32339     /* End of the user code for procedure-prolog . */
32340 
32341 /* User-specified code, instruction-end-c part: beginning. */
32342 
32343 
32344 /* User-specified code, instruction-end-c part: end */
32345 
32346     /* Undefine the procedure-prolog argument macros so they can't be used
32347        by mistake in the instruction body coming next. */
32348 
32349 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32350 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32351 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32352 
32353   }
32354   /* Undefine the link macro. */
32355 #   undef JITTER_LINK
32356 
32357  JITTER_INSTRUCTION_EPILOG_(procedure-prolog, procedure_mprolog, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32358 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32359 
32360   JITTER_INSTRUCTION_PROLOG_(push-false, push_mfalse, hot)
32361   {
32362     /* This specialized instruction is not a replacement. */
32363 #   undef JITTER_BRANCH_FAST
32364 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32365 #   undef JITTER_BRANCH_FAST_IF_ZERO
32366 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32367 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32368 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32369 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32370 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32371 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32372 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32373 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32374 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32375 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32376 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32377 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32378 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32379 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32380 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32381 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32382 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32383 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32384 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32385 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32386 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32387 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32388 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32389 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32390 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32391 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32392 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32393 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32394 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32395 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32396 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32397 #   undef JITTER_BRANCH_FAST_IF_AND
32398 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32399 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32400 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32401 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32402 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32403 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32404 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32405 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32406 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32407 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32408 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32409 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32410 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32411 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32412 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32413 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32414 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32415 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32416 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32417 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32418 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32419 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32420 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32421 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32422 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32423 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32424 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32425 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32426 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32427 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       174
32428 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-false
32429 
32430 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mfalse
32431 
32432   /* The residual arity for this instruction does not depend on fast labels. */
32433   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32434 
32435 
32436 #if defined (JITTER_PROFILE_SAMPLE)
32437   JITTER_PROFILE_SAMPLE_UPDATE
32438      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32439       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32440   /* Force the compiler not move sample-profiling instrumentation
32441      beyond this point; this way the actual user code is timed.
32442      This is still not perfect, as residuals are materialised before
32443      we arrive here, but should be adequate at least for slow VM
32444      instructions. */
32445   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32446 #endif
32447 #if defined (JITTER_PROFILE_COUNT)
32448   /* Notice that, differently from the code above, this
32449      instrumentation code *can* be reordered freely: as long as a
32450      VM instruction is counted, the count increment can be placed
32451      anyehere.  Let GCC move this code and possibly achieve better
32452      throughput by exploiting instruction-level parallelism and
32453      therefore approximate more closely a non-profiled build. */
32454   JITTER_PROFILE_COUNT_UPDATE
32455      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32456       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32457 #endif
32458 
32459 /* User-specified code, instruction-beginning-c part: beginning. */
32460 
32461 
32462 /* User-specified code, instruction-beginning-c part: end */
32463 
32464 
32465     /* User code for push-false . */
32466 
32467     JITTER_PUSH_MAINSTACK(JITTERLISP_FALSE);
32468 
32469     /* End of the user code for push-false . */
32470 
32471 /* User-specified code, instruction-end-c part: beginning. */
32472 
32473 
32474 /* User-specified code, instruction-end-c part: end */
32475 
32476     /* Undefine the push-false argument macros so they can't be used
32477        by mistake in the instruction body coming next. */
32478 
32479 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32480 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32481 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32482 
32483   }
32484  JITTER_INSTRUCTION_EPILOG_(push-false, push_mfalse, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32485 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32486 
32487   JITTER_INSTRUCTION_PROLOG_(push-global/nR/fR, push_mglobal__nR__fR, cold)
32488   {
32489     /* This specialized instruction is not a replacement. */
32490 #   undef JITTER_BRANCH_FAST
32491 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32492 #   undef JITTER_BRANCH_FAST_IF_ZERO
32493 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32494 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32495 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32496 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32497 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32498 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32499 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32500 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32501 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32502 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32503 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32504 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32505 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32506 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32507 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32508 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32509 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32510 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32511 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32512 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32513 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32514 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32515 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32516 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32517 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32518 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32519 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32520 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32521 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32522 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32523 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32524 #   undef JITTER_BRANCH_FAST_IF_AND
32525 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32526 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32527 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32528 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32529 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32530 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32531 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32532 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32533 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32534 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32535 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32536 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32537 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32538 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32539 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32540 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32541 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32542 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32543 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32544 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32545 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32546 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32547 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32548 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32549 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32550 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32551 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32552 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32553 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32554 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       175
32555 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-global/nR/fR
32556 
32557 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mglobal__nR__fR
32558 
32559   /* The residual arity varies depending on whether we have fast labels. */
32560 #ifdef JITTER_HAVE_PATCH_IN
32561   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
32562 #else
32563   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
32564 #endif // #ifdef JITTER_HAVE_PATCH_IN
32565 
32566   /* Define argument-access macros for push-global/nR/fR . */
32567 #ifdef JITTER_HAVE_PATCH_IN
32568   /* Define argument-access macros assuming that fast branches are enabled. */
32569     /* The 0th argument is a residual literal. */
32570 #if defined(JITTER_DISPATCH_NO_THREADING)
32571 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
32572     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
32573 #elif defined (JITTER_REPLICATE)
32574 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
32575 #else
32576 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
32577 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32578 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32579 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32580 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32581 
32582     /* The 1th argument is a "residual" fast label.  Define its
32583        _ARGF macro as the residual *index* (counting only fast labels, 0-based),
32584        so that at replication time we know what instruction address to patch in. */
32585 #   define JITTER_ARGF1 0
32586     /* JITTER_ARG1 is intentionally not defined for a fast label. */
32587 
32588 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
32589 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
32590 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
32591 
32592 #else
32593   /* Define argument-access macros assuming that fast branches are disabled. */
32594     /* The 0th argument is a residual literal. */
32595 #if defined(JITTER_DISPATCH_NO_THREADING)
32596 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
32597     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
32598 #elif defined (JITTER_REPLICATE)
32599 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
32600 #else
32601 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
32602 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32603 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32604 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32605 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32606 #   define JITTER_ARGF0 JITTER_ARGP0
32607 
32608 #if defined(JITTER_DISPATCH_NO_THREADING)
32609 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
32610     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
32611 #elif defined (JITTER_REPLICATE)
32612 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
32613 #else
32614 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
32615 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32616 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
32617 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
32618 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
32619 #   define JITTER_ARGF1 JITTER_ARGP1
32620 
32621 # endif // #ifdef JITTER_HAVE_PATCH_IN
32622 
32623 #if defined (JITTER_PROFILE_SAMPLE)
32624   JITTER_PROFILE_SAMPLE_UPDATE
32625      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32626       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32627   /* Force the compiler not move sample-profiling instrumentation
32628      beyond this point; this way the actual user code is timed.
32629      This is still not perfect, as residuals are materialised before
32630      we arrive here, but should be adequate at least for slow VM
32631      instructions. */
32632   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32633 #endif
32634 #if defined (JITTER_PROFILE_COUNT)
32635   /* Notice that, differently from the code above, this
32636      instrumentation code *can* be reordered freely: as long as a
32637      VM instruction is counted, the count increment can be placed
32638      anyehere.  Let GCC move this code and possibly achieve better
32639      throughput by exploiting instruction-level parallelism and
32640      therefore approximate more closely a non-profiled build. */
32641   JITTER_PROFILE_COUNT_UPDATE
32642      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32643       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32644 #endif
32645 
32646 /* User-specified code, instruction-beginning-c part: beginning. */
32647 
32648 
32649 /* User-specified code, instruction-beginning-c part: end */
32650 
32651 
32652     /* User code for push-global/nR/fR . */
32653 
32654     jitterlisp_object tagged_symbol = JITTER_ARGN0;
32655     struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
32656 
32657 #ifndef JITTERLISP_UNSAFE
32658     JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
32659                                  JITTER_ARGF1);
32660 #endif // #ifndef JITTERLISP_UNSAFE
32661 
32662 //    JITTER_PUSH_MAINSTACK(symbol->global_value);
32663     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
32664     JITTER_TOP_MAINSTACK() = symbol->global_value;
32665 
32666     /* End of the user code for push-global/nR/fR . */
32667 
32668 /* User-specified code, instruction-end-c part: beginning. */
32669 
32670 
32671 /* User-specified code, instruction-end-c part: end */
32672 
32673     /* Undefine the push-global/nR/fR argument macros so they can't be used
32674        by mistake in the instruction body coming next. */
32675 #   undef JITTER_SLOW_REGISTER_OFFSET0
32676 #   undef JITTER_ARG0
32677 #   undef JITTER_ARGN0
32678 #   undef JITTER_ARGU0
32679 #   undef JITTER_ARGP0
32680 #   undef JITTER_ARGF0
32681 #   undef JITTER_SLOW_REGISTER_OFFSET1
32682 #   undef JITTER_ARG1
32683 #   undef JITTER_ARGN1
32684 #   undef JITTER_ARGU1
32685 #   undef JITTER_ARGP1
32686 #   undef JITTER_ARGF1
32687 
32688 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32689 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32690 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32691 
32692   }
32693  JITTER_INSTRUCTION_EPILOG_(push-global/nR/fR, push_mglobal__nR__fR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32694 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32695 
32696   JITTER_INSTRUCTION_PROLOG_(push-literal/nR, push_mliteral__nR, cold)
32697   {
32698     /* This specialized instruction is not a replacement. */
32699 #   undef JITTER_BRANCH_FAST
32700 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32701 #   undef JITTER_BRANCH_FAST_IF_ZERO
32702 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32703 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32704 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32705 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32706 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32707 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32708 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32709 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32710 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32711 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32712 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32713 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32714 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32715 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32716 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32717 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32718 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32719 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32720 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32721 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32722 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32723 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32724 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32725 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32726 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32727 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32728 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32729 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32730 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32731 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32732 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32733 #   undef JITTER_BRANCH_FAST_IF_AND
32734 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32735 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32736 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32737 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32738 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32739 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32740 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32741 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32742 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32743 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32744 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32745 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32746 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32747 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32748 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32749 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32750 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32751 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32752 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32753 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32754 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32755 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32756 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32757 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32758 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32759 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32760 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32761 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32762 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32763 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       176
32764 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-literal/nR
32765 
32766 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mliteral__nR
32767 
32768   /* The residual arity for this instruction does not depend on fast labels. */
32769   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
32770 
32771     /* The 0th argument is a residual literal. */
32772 #if defined(JITTER_DISPATCH_NO_THREADING)
32773 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
32774     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
32775 #elif defined (JITTER_REPLICATE)
32776 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
32777 #else
32778 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
32779 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
32780 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
32781 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
32782 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
32783 #   define JITTER_ARGF0 JITTER_ARGP0
32784 
32785 
32786 #if defined (JITTER_PROFILE_SAMPLE)
32787   JITTER_PROFILE_SAMPLE_UPDATE
32788      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32789       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32790   /* Force the compiler not move sample-profiling instrumentation
32791      beyond this point; this way the actual user code is timed.
32792      This is still not perfect, as residuals are materialised before
32793      we arrive here, but should be adequate at least for slow VM
32794      instructions. */
32795   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32796 #endif
32797 #if defined (JITTER_PROFILE_COUNT)
32798   /* Notice that, differently from the code above, this
32799      instrumentation code *can* be reordered freely: as long as a
32800      VM instruction is counted, the count increment can be placed
32801      anyehere.  Let GCC move this code and possibly achieve better
32802      throughput by exploiting instruction-level parallelism and
32803      therefore approximate more closely a non-profiled build. */
32804   JITTER_PROFILE_COUNT_UPDATE
32805      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32806       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32807 #endif
32808 
32809 /* User-specified code, instruction-beginning-c part: beginning. */
32810 
32811 
32812 /* User-specified code, instruction-beginning-c part: end */
32813 
32814 
32815     /* User code for push-literal/nR . */
32816 
32817     jitterlisp_object k = JITTER_ARGN0;
32818     JITTER_PUSH_MAINSTACK(k);
32819 
32820     /* End of the user code for push-literal/nR . */
32821 
32822 /* User-specified code, instruction-end-c part: beginning. */
32823 
32824 
32825 /* User-specified code, instruction-end-c part: end */
32826 
32827     /* Undefine the push-literal/nR argument macros so they can't be used
32828        by mistake in the instruction body coming next. */
32829 #   undef JITTER_SLOW_REGISTER_OFFSET0
32830 #   undef JITTER_ARG0
32831 #   undef JITTER_ARGN0
32832 #   undef JITTER_ARGU0
32833 #   undef JITTER_ARGP0
32834 #   undef JITTER_ARGF0
32835 
32836 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32837 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32838 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32839 
32840   }
32841  JITTER_INSTRUCTION_EPILOG_(push-literal/nR, push_mliteral__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32842 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32843 
32844   JITTER_INSTRUCTION_PROLOG_(push-nil, push_mnil, hot)
32845   {
32846     /* This specialized instruction is not a replacement. */
32847 #   undef JITTER_BRANCH_FAST
32848 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32849 #   undef JITTER_BRANCH_FAST_IF_ZERO
32850 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32851 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32852 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32853 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32854 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32855 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32856 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32857 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32858 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32859 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32860 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32861 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32862 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32863 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32864 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32865 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32866 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32867 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32868 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32869 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32870 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32871 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32872 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32873 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32874 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
32875 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32876 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
32877 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32878 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
32879 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32880 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
32881 #   undef JITTER_BRANCH_FAST_IF_AND
32882 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
32883 #   undef JITTER_BRANCH_FAST_IF_NOTAND
32884 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
32885 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32886 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
32887 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32888 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
32889 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32890 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
32891 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32892 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
32893 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32894 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
32895 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32896 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
32897 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32898 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
32899 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32900 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
32901 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32902 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
32903 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32904 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
32905 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32906 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
32907 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32908 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
32909 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32910 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
32911 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       177
32912 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-nil
32913 
32914 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mnil
32915 
32916   /* The residual arity for this instruction does not depend on fast labels. */
32917   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
32918 
32919 
32920 #if defined (JITTER_PROFILE_SAMPLE)
32921   JITTER_PROFILE_SAMPLE_UPDATE
32922      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32923       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32924   /* Force the compiler not move sample-profiling instrumentation
32925      beyond this point; this way the actual user code is timed.
32926      This is still not perfect, as residuals are materialised before
32927      we arrive here, but should be adequate at least for slow VM
32928      instructions. */
32929   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
32930 #endif
32931 #if defined (JITTER_PROFILE_COUNT)
32932   /* Notice that, differently from the code above, this
32933      instrumentation code *can* be reordered freely: as long as a
32934      VM instruction is counted, the count increment can be placed
32935      anyehere.  Let GCC move this code and possibly achieve better
32936      throughput by exploiting instruction-level parallelism and
32937      therefore approximate more closely a non-profiled build. */
32938   JITTER_PROFILE_COUNT_UPDATE
32939      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
32940       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
32941 #endif
32942 
32943 /* User-specified code, instruction-beginning-c part: beginning. */
32944 
32945 
32946 /* User-specified code, instruction-beginning-c part: end */
32947 
32948 
32949     /* User code for push-nil . */
32950 
32951     JITTER_PUSH_MAINSTACK(JITTERLISP_EMPTY_LIST);
32952 
32953     /* End of the user code for push-nil . */
32954 
32955 /* User-specified code, instruction-end-c part: beginning. */
32956 
32957 
32958 /* User-specified code, instruction-end-c part: end */
32959 
32960     /* Undefine the push-nil argument macros so they can't be used
32961        by mistake in the instruction body coming next. */
32962 
32963 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
32964 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
32965 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
32966 
32967   }
32968  JITTER_INSTRUCTION_EPILOG_(push-nil, push_mnil, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
32969 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
32970 
32971   JITTER_INSTRUCTION_PROLOG_(push-nothing, push_mnothing, hot)
32972   {
32973     /* This specialized instruction is not a replacement. */
32974 #   undef JITTER_BRANCH_FAST
32975 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
32976 #   undef JITTER_BRANCH_FAST_IF_ZERO
32977 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
32978 #   undef JITTER_BRANCH_FAST_IF_NONZERO
32979 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
32980 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
32981 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
32982 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
32983 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
32984 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
32985 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
32986 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
32987 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
32988 #   undef JITTER_BRANCH_FAST_IF_EQUAL
32989 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
32990 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
32991 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
32992 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
32993 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
32994 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32995 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
32996 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32997 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
32998 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
32999 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33000 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33001 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33002 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33003 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33004 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33005 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33006 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33007 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33008 #   undef JITTER_BRANCH_FAST_IF_AND
33009 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33010 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33011 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33012 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33013 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33014 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33015 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33016 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33017 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33018 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33019 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33020 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33021 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33022 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33023 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33024 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33025 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33026 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33027 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33028 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33029 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33030 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33031 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33032 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33033 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33034 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33035 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33036 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33037 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33038 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       178
33039 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-nothing
33040 
33041 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mnothing
33042 
33043   /* The residual arity for this instruction does not depend on fast labels. */
33044   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
33045 
33046 
33047 #if defined (JITTER_PROFILE_SAMPLE)
33048   JITTER_PROFILE_SAMPLE_UPDATE
33049      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33050       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33051   /* Force the compiler not move sample-profiling instrumentation
33052      beyond this point; this way the actual user code is timed.
33053      This is still not perfect, as residuals are materialised before
33054      we arrive here, but should be adequate at least for slow VM
33055      instructions. */
33056   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33057 #endif
33058 #if defined (JITTER_PROFILE_COUNT)
33059   /* Notice that, differently from the code above, this
33060      instrumentation code *can* be reordered freely: as long as a
33061      VM instruction is counted, the count increment can be placed
33062      anyehere.  Let GCC move this code and possibly achieve better
33063      throughput by exploiting instruction-level parallelism and
33064      therefore approximate more closely a non-profiled build. */
33065   JITTER_PROFILE_COUNT_UPDATE
33066      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33067       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33068 #endif
33069 
33070 /* User-specified code, instruction-beginning-c part: beginning. */
33071 
33072 
33073 /* User-specified code, instruction-beginning-c part: end */
33074 
33075 
33076     /* User code for push-nothing . */
33077 
33078     JITTER_PUSH_MAINSTACK(JITTERLISP_NOTHING);
33079 
33080     /* End of the user code for push-nothing . */
33081 
33082 /* User-specified code, instruction-end-c part: beginning. */
33083 
33084 
33085 /* User-specified code, instruction-end-c part: end */
33086 
33087     /* Undefine the push-nothing argument macros so they can't be used
33088        by mistake in the instruction body coming next. */
33089 
33090 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33091 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33092 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33093 
33094   }
33095  JITTER_INSTRUCTION_EPILOG_(push-nothing, push_mnothing, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33096 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33097 
33098   JITTER_INSTRUCTION_PROLOG_(push-one, push_mone, hot)
33099   {
33100     /* This specialized instruction is not a replacement. */
33101 #   undef JITTER_BRANCH_FAST
33102 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33103 #   undef JITTER_BRANCH_FAST_IF_ZERO
33104 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33105 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33106 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33107 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33108 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33109 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33110 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33111 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33112 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33113 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33114 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33115 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33116 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33117 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33118 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33119 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33120 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33121 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33122 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33123 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33124 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33125 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33126 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33127 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33128 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33129 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33130 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33131 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33132 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33133 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33134 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33135 #   undef JITTER_BRANCH_FAST_IF_AND
33136 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33137 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33138 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33139 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33140 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33141 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33142 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33143 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33144 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33145 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33146 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33147 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33148 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33149 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33150 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33151 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33152 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33153 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33154 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33155 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33156 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33157 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33158 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33159 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33160 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33161 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33162 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33163 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33164 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33165 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       179
33166 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-one
33167 
33168 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mone
33169 
33170   /* The residual arity for this instruction does not depend on fast labels. */
33171   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
33172 
33173 
33174 #if defined (JITTER_PROFILE_SAMPLE)
33175   JITTER_PROFILE_SAMPLE_UPDATE
33176      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33177       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33178   /* Force the compiler not move sample-profiling instrumentation
33179      beyond this point; this way the actual user code is timed.
33180      This is still not perfect, as residuals are materialised before
33181      we arrive here, but should be adequate at least for slow VM
33182      instructions. */
33183   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33184 #endif
33185 #if defined (JITTER_PROFILE_COUNT)
33186   /* Notice that, differently from the code above, this
33187      instrumentation code *can* be reordered freely: as long as a
33188      VM instruction is counted, the count increment can be placed
33189      anyehere.  Let GCC move this code and possibly achieve better
33190      throughput by exploiting instruction-level parallelism and
33191      therefore approximate more closely a non-profiled build. */
33192   JITTER_PROFILE_COUNT_UPDATE
33193      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33194       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33195 #endif
33196 
33197 /* User-specified code, instruction-beginning-c part: beginning. */
33198 
33199 
33200 /* User-specified code, instruction-beginning-c part: end */
33201 
33202 
33203     /* User code for push-one . */
33204 
33205     JITTER_PUSH_MAINSTACK(JITTERLISP_FIXNUM_ENCODE(1));
33206 
33207     /* End of the user code for push-one . */
33208 
33209 /* User-specified code, instruction-end-c part: beginning. */
33210 
33211 
33212 /* User-specified code, instruction-end-c part: end */
33213 
33214     /* Undefine the push-one argument macros so they can't be used
33215        by mistake in the instruction body coming next. */
33216 
33217 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33218 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33219 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33220 
33221   }
33222  JITTER_INSTRUCTION_EPILOG_(push-one, push_mone, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33223 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33224 
33225   JITTER_INSTRUCTION_PROLOG_(push-register/%rR, push_mregister___rrR, cold)
33226   {
33227     /* This specialized instruction is not a replacement. */
33228 #   undef JITTER_BRANCH_FAST
33229 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33230 #   undef JITTER_BRANCH_FAST_IF_ZERO
33231 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33232 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33233 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33234 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33235 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33236 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33237 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33238 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33239 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33240 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33241 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33242 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33243 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33244 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33245 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33246 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33247 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33248 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33249 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33250 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33251 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33252 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33253 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33254 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33255 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33256 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33257 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33258 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33259 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33260 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33261 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33262 #   undef JITTER_BRANCH_FAST_IF_AND
33263 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33264 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33265 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33266 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33267 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33268 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33269 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33270 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33271 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33272 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33273 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33274 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33275 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33276 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33277 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33278 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33279 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33280 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33281 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33282 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33283 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33284 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33285 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33286 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33287 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33288 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33289 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33290 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33291 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33292 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       180
33293 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-register/%rR
33294 
33295 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mregister___rrR
33296 
33297   /* The residual arity for this instruction does not depend on fast labels. */
33298   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
33299 
33300     /* The 0th argument is a slow (therefore residual, passed as an offset)
33301         register. */
33302   /* Define a macro expanding to the slow register offset. */
33303 #if defined(JITTER_DISPATCH_NO_THREADING)
33304 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
33305 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
33306 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
33307 #else
33308 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
33309 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33310   /* Define a macro expanding to an l-value for the VM register content. */
33311 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
33312 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33313 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33314 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33315 #   define JITTER_ARGF0 JITTER_ARGP0
33316 
33317 
33318 #if defined (JITTER_PROFILE_SAMPLE)
33319   JITTER_PROFILE_SAMPLE_UPDATE
33320      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33321       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33322   /* Force the compiler not move sample-profiling instrumentation
33323      beyond this point; this way the actual user code is timed.
33324      This is still not perfect, as residuals are materialised before
33325      we arrive here, but should be adequate at least for slow VM
33326      instructions. */
33327   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33328 #endif
33329 #if defined (JITTER_PROFILE_COUNT)
33330   /* Notice that, differently from the code above, this
33331      instrumentation code *can* be reordered freely: as long as a
33332      VM instruction is counted, the count increment can be placed
33333      anyehere.  Let GCC move this code and possibly achieve better
33334      throughput by exploiting instruction-level parallelism and
33335      therefore approximate more closely a non-profiled build. */
33336   JITTER_PROFILE_COUNT_UPDATE
33337      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33338       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33339 #endif
33340 
33341 /* User-specified code, instruction-beginning-c part: beginning. */
33342 
33343 
33344 /* User-specified code, instruction-beginning-c part: end */
33345 
33346 
33347     /* User code for push-register/%rR . */
33348 
33349     jitterlisp_object k = JITTER_ARG0;
33350     JITTER_PUSH_MAINSTACK(k);
33351 
33352     /* End of the user code for push-register/%rR . */
33353 
33354 /* User-specified code, instruction-end-c part: beginning. */
33355 
33356 
33357 /* User-specified code, instruction-end-c part: end */
33358 
33359     /* Undefine the push-register/%rR argument macros so they can't be used
33360        by mistake in the instruction body coming next. */
33361 #   undef JITTER_SLOW_REGISTER_OFFSET0
33362 #   undef JITTER_ARG0
33363 #   undef JITTER_ARGN0
33364 #   undef JITTER_ARGU0
33365 #   undef JITTER_ARGP0
33366 #   undef JITTER_ARGF0
33367 
33368 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33369 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33370 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33371 
33372   }
33373  JITTER_INSTRUCTION_EPILOG_(push-register/%rR, push_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33374 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33375 
33376   JITTER_INSTRUCTION_PROLOG_(push-unspecified, push_munspecified, hot)
33377   {
33378     /* This specialized instruction is not a replacement. */
33379 #   undef JITTER_BRANCH_FAST
33380 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33381 #   undef JITTER_BRANCH_FAST_IF_ZERO
33382 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33383 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33384 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33385 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33386 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33387 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33388 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33389 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33390 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33391 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33392 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33393 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33394 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33395 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33396 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33397 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33398 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33399 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33400 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33401 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33402 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33403 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33404 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33405 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33406 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33407 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33408 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33409 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33410 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33411 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33412 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33413 #   undef JITTER_BRANCH_FAST_IF_AND
33414 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33415 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33416 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33417 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33418 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33419 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33420 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33421 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33422 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33423 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33424 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33425 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33426 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33427 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33428 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33429 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33430 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33431 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33432 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33433 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33434 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33435 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33436 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33437 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33438 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33439 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33440 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33441 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33442 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33443 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       181
33444 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-unspecified
33445 
33446 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_munspecified
33447 
33448   /* The residual arity for this instruction does not depend on fast labels. */
33449   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
33450 
33451 
33452 #if defined (JITTER_PROFILE_SAMPLE)
33453   JITTER_PROFILE_SAMPLE_UPDATE
33454      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33455       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33456   /* Force the compiler not move sample-profiling instrumentation
33457      beyond this point; this way the actual user code is timed.
33458      This is still not perfect, as residuals are materialised before
33459      we arrive here, but should be adequate at least for slow VM
33460      instructions. */
33461   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33462 #endif
33463 #if defined (JITTER_PROFILE_COUNT)
33464   /* Notice that, differently from the code above, this
33465      instrumentation code *can* be reordered freely: as long as a
33466      VM instruction is counted, the count increment can be placed
33467      anyehere.  Let GCC move this code and possibly achieve better
33468      throughput by exploiting instruction-level parallelism and
33469      therefore approximate more closely a non-profiled build. */
33470   JITTER_PROFILE_COUNT_UPDATE
33471      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33472       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33473 #endif
33474 
33475 /* User-specified code, instruction-beginning-c part: beginning. */
33476 
33477 
33478 /* User-specified code, instruction-beginning-c part: end */
33479 
33480 
33481     /* User code for push-unspecified . */
33482 
33483     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
33484 
33485     /* End of the user code for push-unspecified . */
33486 
33487 /* User-specified code, instruction-end-c part: beginning. */
33488 
33489 
33490 /* User-specified code, instruction-end-c part: end */
33491 
33492     /* Undefine the push-unspecified argument macros so they can't be used
33493        by mistake in the instruction body coming next. */
33494 
33495 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33496 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33497 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33498 
33499   }
33500  JITTER_INSTRUCTION_EPILOG_(push-unspecified, push_munspecified, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33501 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33502 
33503   JITTER_INSTRUCTION_PROLOG_(push-zero, push_mzero, hot)
33504   {
33505     /* This specialized instruction is not a replacement. */
33506 #   undef JITTER_BRANCH_FAST
33507 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33508 #   undef JITTER_BRANCH_FAST_IF_ZERO
33509 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33510 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33511 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33512 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33513 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33514 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33515 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33516 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33517 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33518 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33519 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33520 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33521 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33522 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33523 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33524 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33525 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33526 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33527 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33528 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33529 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33530 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33531 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33532 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33533 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33534 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33535 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33536 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33537 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33538 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33539 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33540 #   undef JITTER_BRANCH_FAST_IF_AND
33541 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33542 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33543 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33544 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33545 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33546 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33547 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33548 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33549 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33550 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33551 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33552 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33553 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33554 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33555 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33556 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33557 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33558 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33559 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33560 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33561 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33562 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33563 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33564 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33565 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33566 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33567 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33568 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33569 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33570 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       182
33571 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         push-zero
33572 
33573 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME push_mzero
33574 
33575   /* The residual arity for this instruction does not depend on fast labels. */
33576   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
33577 
33578 
33579 #if defined (JITTER_PROFILE_SAMPLE)
33580   JITTER_PROFILE_SAMPLE_UPDATE
33581      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33582       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33583   /* Force the compiler not move sample-profiling instrumentation
33584      beyond this point; this way the actual user code is timed.
33585      This is still not perfect, as residuals are materialised before
33586      we arrive here, but should be adequate at least for slow VM
33587      instructions. */
33588   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33589 #endif
33590 #if defined (JITTER_PROFILE_COUNT)
33591   /* Notice that, differently from the code above, this
33592      instrumentation code *can* be reordered freely: as long as a
33593      VM instruction is counted, the count increment can be placed
33594      anyehere.  Let GCC move this code and possibly achieve better
33595      throughput by exploiting instruction-level parallelism and
33596      therefore approximate more closely a non-profiled build. */
33597   JITTER_PROFILE_COUNT_UPDATE
33598      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33599       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33600 #endif
33601 
33602 /* User-specified code, instruction-beginning-c part: beginning. */
33603 
33604 
33605 /* User-specified code, instruction-beginning-c part: end */
33606 
33607 
33608     /* User code for push-zero . */
33609 
33610     JITTER_PUSH_MAINSTACK(JITTERLISP_FIXNUM_ENCODE(0));
33611 
33612     /* End of the user code for push-zero . */
33613 
33614 /* User-specified code, instruction-end-c part: beginning. */
33615 
33616 
33617 /* User-specified code, instruction-end-c part: end */
33618 
33619     /* Undefine the push-zero argument macros so they can't be used
33620        by mistake in the instruction body coming next. */
33621 
33622 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33623 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33624 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33625 
33626   }
33627  JITTER_INSTRUCTION_EPILOG_(push-zero, push_mzero, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33628 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33629 
33630   JITTER_INSTRUCTION_PROLOG_(register-to-register/%rR/%rR, register_mto_mregister___rrR___rrR, cold)
33631   {
33632     /* This specialized instruction is not a replacement. */
33633 #   undef JITTER_BRANCH_FAST
33634 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33635 #   undef JITTER_BRANCH_FAST_IF_ZERO
33636 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33637 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33638 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33639 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33640 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33641 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33642 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33643 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33644 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33645 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33646 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33647 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33648 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33649 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33650 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33651 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33652 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33653 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33654 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33655 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33656 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33657 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33658 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33659 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33660 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33661 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33662 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33663 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33664 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33665 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33666 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33667 #   undef JITTER_BRANCH_FAST_IF_AND
33668 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33669 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33670 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33671 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33672 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33673 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33674 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33675 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33676 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33677 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33678 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33679 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33680 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33681 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33682 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33683 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33684 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33685 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33686 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33687 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33688 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33689 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33690 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33691 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33692 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33693 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33694 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33695 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33696 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33697 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       183
33698 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         register-to-register/%rR/%rR
33699 
33700 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME register_mto_mregister___rrR___rrR
33701 
33702   /* The residual arity for this instruction does not depend on fast labels. */
33703   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
33704 
33705     /* The 0th argument is a slow (therefore residual, passed as an offset)
33706         register. */
33707   /* Define a macro expanding to the slow register offset. */
33708 #if defined(JITTER_DISPATCH_NO_THREADING)
33709 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
33710 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
33711 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
33712 #else
33713 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
33714 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33715   /* Define a macro expanding to an l-value for the VM register content. */
33716 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
33717 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33718 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33719 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33720 #   define JITTER_ARGF0 JITTER_ARGP0
33721 
33722     /* The 1th argument is a slow (therefore residual, passed as an offset)
33723         register. */
33724   /* Define a macro expanding to the slow register offset. */
33725 #if defined(JITTER_DISPATCH_NO_THREADING)
33726 # define JITTER_SLOW_REGISTER_OFFSET1 (JITTER_RESIDUAL_ARGUMENT_1.fixnum)
33727 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
33728 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[1]).fixnum)
33729 #else
33730 # define JITTER_SLOW_REGISTER_OFFSET1 ((((union jitter_word*)jitter_ip)[2]).fixnum)
33731 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33732   /* Define a macro expanding to an l-value for the VM register content. */
33733 #   define JITTER_ARG1  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET1)
33734 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
33735 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
33736 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
33737 #   define JITTER_ARGF1 JITTER_ARGP1
33738 
33739 
33740 #if defined (JITTER_PROFILE_SAMPLE)
33741   JITTER_PROFILE_SAMPLE_UPDATE
33742      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33743       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33744   /* Force the compiler not move sample-profiling instrumentation
33745      beyond this point; this way the actual user code is timed.
33746      This is still not perfect, as residuals are materialised before
33747      we arrive here, but should be adequate at least for slow VM
33748      instructions. */
33749   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33750 #endif
33751 #if defined (JITTER_PROFILE_COUNT)
33752   /* Notice that, differently from the code above, this
33753      instrumentation code *can* be reordered freely: as long as a
33754      VM instruction is counted, the count increment can be placed
33755      anyehere.  Let GCC move this code and possibly achieve better
33756      throughput by exploiting instruction-level parallelism and
33757      therefore approximate more closely a non-profiled build. */
33758   JITTER_PROFILE_COUNT_UPDATE
33759      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33760       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33761 #endif
33762 
33763 /* User-specified code, instruction-beginning-c part: beginning. */
33764 
33765 
33766 /* User-specified code, instruction-beginning-c part: end */
33767 
33768 
33769     /* User code for register-to-register/%rR/%rR . */
33770 
33771     JITTER_ARG1 = JITTER_ARG0;
33772 
33773     /* End of the user code for register-to-register/%rR/%rR . */
33774 
33775 /* User-specified code, instruction-end-c part: beginning. */
33776 
33777 
33778 /* User-specified code, instruction-end-c part: end */
33779 
33780     /* Undefine the register-to-register/%rR/%rR argument macros so they can't be used
33781        by mistake in the instruction body coming next. */
33782 #   undef JITTER_SLOW_REGISTER_OFFSET0
33783 #   undef JITTER_ARG0
33784 #   undef JITTER_ARGN0
33785 #   undef JITTER_ARGU0
33786 #   undef JITTER_ARGP0
33787 #   undef JITTER_ARGF0
33788 #   undef JITTER_SLOW_REGISTER_OFFSET1
33789 #   undef JITTER_ARG1
33790 #   undef JITTER_ARGN1
33791 #   undef JITTER_ARGU1
33792 #   undef JITTER_ARGP1
33793 #   undef JITTER_ARGF1
33794 
33795 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33796 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33797 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33798 
33799   }
33800  JITTER_INSTRUCTION_EPILOG_(register-to-register/%rR/%rR, register_mto_mregister___rrR___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33801 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33802 
33803   JITTER_INSTRUCTION_PROLOG_(restore-register/%rR, restore_mregister___rrR, cold)
33804   {
33805     /* This specialized instruction is not a replacement. */
33806 #   undef JITTER_BRANCH_FAST
33807 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33808 #   undef JITTER_BRANCH_FAST_IF_ZERO
33809 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33810 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33811 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33812 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33813 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33814 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33815 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33816 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33817 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33818 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33819 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33820 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33821 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33822 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33823 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33824 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33825 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33826 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33827 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33828 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33829 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33830 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33831 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33832 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33833 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33834 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33835 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33836 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33837 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33838 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33839 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33840 #   undef JITTER_BRANCH_FAST_IF_AND
33841 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33842 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33843 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33844 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33845 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33846 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33847 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33848 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33849 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
33850 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33851 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
33852 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33853 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
33854 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33855 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
33856 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33857 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
33858 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33859 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
33860 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33861 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
33862 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33863 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
33864 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33865 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
33866 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33867 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
33868 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33869 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
33870 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       184
33871 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         restore-register/%rR
33872 
33873 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME restore_mregister___rrR
33874 
33875   /* The residual arity for this instruction does not depend on fast labels. */
33876   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
33877 
33878     /* The 0th argument is a slow (therefore residual, passed as an offset)
33879         register. */
33880   /* Define a macro expanding to the slow register offset. */
33881 #if defined(JITTER_DISPATCH_NO_THREADING)
33882 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
33883 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
33884 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
33885 #else
33886 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
33887 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
33888   /* Define a macro expanding to an l-value for the VM register content. */
33889 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
33890 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
33891 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
33892 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
33893 #   define JITTER_ARGF0 JITTER_ARGP0
33894 
33895 
33896 #if defined (JITTER_PROFILE_SAMPLE)
33897   JITTER_PROFILE_SAMPLE_UPDATE
33898      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33899       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33900   /* Force the compiler not move sample-profiling instrumentation
33901      beyond this point; this way the actual user code is timed.
33902      This is still not perfect, as residuals are materialised before
33903      we arrive here, but should be adequate at least for slow VM
33904      instructions. */
33905   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
33906 #endif
33907 #if defined (JITTER_PROFILE_COUNT)
33908   /* Notice that, differently from the code above, this
33909      instrumentation code *can* be reordered freely: as long as a
33910      VM instruction is counted, the count increment can be placed
33911      anyehere.  Let GCC move this code and possibly achieve better
33912      throughput by exploiting instruction-level parallelism and
33913      therefore approximate more closely a non-profiled build. */
33914   JITTER_PROFILE_COUNT_UPDATE
33915      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
33916       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
33917 #endif
33918 
33919 /* User-specified code, instruction-beginning-c part: beginning. */
33920 
33921 
33922 /* User-specified code, instruction-beginning-c part: end */
33923 
33924 
33925     /* User code for restore-register/%rR . */
33926 
33927     JITTER_ARG0 = JITTER_TOP_RETURNSTACK();
33928     JITTER_DROP_RETURNSTACK();
33929 
33930     /* End of the user code for restore-register/%rR . */
33931 
33932 /* User-specified code, instruction-end-c part: beginning. */
33933 
33934 
33935 /* User-specified code, instruction-end-c part: end */
33936 
33937     /* Undefine the restore-register/%rR argument macros so they can't be used
33938        by mistake in the instruction body coming next. */
33939 #   undef JITTER_SLOW_REGISTER_OFFSET0
33940 #   undef JITTER_ARG0
33941 #   undef JITTER_ARGN0
33942 #   undef JITTER_ARGU0
33943 #   undef JITTER_ARGP0
33944 #   undef JITTER_ARGF0
33945 
33946 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
33947 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
33948 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
33949 
33950   }
33951  JITTER_INSTRUCTION_EPILOG_(restore-register/%rR, restore_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
33952 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
33953 
33954   JITTER_INSTRUCTION_PROLOG_(return, return, hot)
33955   {
33956     /* This specialized instruction is not a replacement. */
33957 #   undef JITTER_BRANCH_FAST
33958 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
33959 #   undef JITTER_BRANCH_FAST_IF_ZERO
33960 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
33961 #   undef JITTER_BRANCH_FAST_IF_NONZERO
33962 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
33963 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
33964 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
33965 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
33966 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
33967 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
33968 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
33969 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
33970 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
33971 #   undef JITTER_BRANCH_FAST_IF_EQUAL
33972 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
33973 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
33974 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
33975 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
33976 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
33977 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33978 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
33979 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33980 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
33981 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33982 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
33983 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33984 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
33985 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33986 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
33987 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33988 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
33989 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33990 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
33991 #   undef JITTER_BRANCH_FAST_IF_AND
33992 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
33993 #   undef JITTER_BRANCH_FAST_IF_NOTAND
33994 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
33995 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33996 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
33997 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33998 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
33999 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34000 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34001 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34002 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34003 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34004 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34005 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34006 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34007 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34008 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34009 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34010 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34011 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34012 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34013 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34014 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34015 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34016 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34017 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34018 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34019 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34020 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34021 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       185
34022 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         return
34023 
34024 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME return
34025 
34026   /* The residual arity for this instruction does not depend on fast labels. */
34027   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
34028 
34029 
34030 #if defined (JITTER_PROFILE_SAMPLE)
34031   JITTER_PROFILE_SAMPLE_UPDATE
34032      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34033       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34034   /* Force the compiler not move sample-profiling instrumentation
34035      beyond this point; this way the actual user code is timed.
34036      This is still not perfect, as residuals are materialised before
34037      we arrive here, but should be adequate at least for slow VM
34038      instructions. */
34039   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34040 #endif
34041 #if defined (JITTER_PROFILE_COUNT)
34042   /* Notice that, differently from the code above, this
34043      instrumentation code *can* be reordered freely: as long as a
34044      VM instruction is counted, the count increment can be placed
34045      anyehere.  Let GCC move this code and possibly achieve better
34046      throughput by exploiting instruction-level parallelism and
34047      therefore approximate more closely a non-profiled build. */
34048   JITTER_PROFILE_COUNT_UPDATE
34049      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34050       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34051 #endif
34052 
34053 /* User-specified code, instruction-beginning-c part: beginning. */
34054 
34055 
34056 /* User-specified code, instruction-beginning-c part: end */
34057 
34058 
34059     /* User code for return . */
34060 
34061     //dump_stacks (1, the_jitter_state_runtime_pointer);
34062     jitter_uint return_address = JITTER_TOP_RETURNSTACK();
34063     JITTER_DROP_RETURNSTACK();
34064     //dump_stacks (2, the_jitter_state_runtime_pointer);
34065     JITTER_RETURN(return_address);
34066     //dump_stacks (1, the_jitter_state_runtime_pointer);
34067 
34068     /* End of the user code for return . */
34069 
34070 /* User-specified code, instruction-end-c part: beginning. */
34071 
34072 
34073 /* User-specified code, instruction-end-c part: end */
34074 
34075     /* Undefine the return argument macros so they can't be used
34076        by mistake in the instruction body coming next. */
34077 
34078 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34079 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34080 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34081 
34082   }
34083  JITTER_INSTRUCTION_EPILOG_(return, return, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34084 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34085 
34086   JITTER_INSTRUCTION_PROLOG_(save-register/%rR, save_mregister___rrR, cold)
34087   {
34088     /* This specialized instruction is not a replacement. */
34089 #   undef JITTER_BRANCH_FAST
34090 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34091 #   undef JITTER_BRANCH_FAST_IF_ZERO
34092 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34093 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34094 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34095 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34096 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34097 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34098 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34099 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34100 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34101 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34102 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34103 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34104 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34105 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34106 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34107 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34108 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34109 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34110 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34111 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34112 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34113 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34114 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34115 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34116 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34117 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34118 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34119 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34120 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34121 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34122 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34123 #   undef JITTER_BRANCH_FAST_IF_AND
34124 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34125 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34126 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34127 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34128 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34129 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34130 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34131 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34132 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34133 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34134 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34135 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34136 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34137 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34138 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34139 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34140 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34141 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34142 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34143 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34144 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34145 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34146 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34147 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34148 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34149 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34150 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34151 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34152 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34153 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       186
34154 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         save-register/%rR
34155 
34156 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME save_mregister___rrR
34157 
34158   /* The residual arity for this instruction does not depend on fast labels. */
34159   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
34160 
34161     /* The 0th argument is a slow (therefore residual, passed as an offset)
34162         register. */
34163   /* Define a macro expanding to the slow register offset. */
34164 #if defined(JITTER_DISPATCH_NO_THREADING)
34165 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
34166 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
34167 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
34168 #else
34169 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
34170 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
34171   /* Define a macro expanding to an l-value for the VM register content. */
34172 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
34173 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34174 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34175 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34176 #   define JITTER_ARGF0 JITTER_ARGP0
34177 
34178 
34179 #if defined (JITTER_PROFILE_SAMPLE)
34180   JITTER_PROFILE_SAMPLE_UPDATE
34181      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34182       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34183   /* Force the compiler not move sample-profiling instrumentation
34184      beyond this point; this way the actual user code is timed.
34185      This is still not perfect, as residuals are materialised before
34186      we arrive here, but should be adequate at least for slow VM
34187      instructions. */
34188   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34189 #endif
34190 #if defined (JITTER_PROFILE_COUNT)
34191   /* Notice that, differently from the code above, this
34192      instrumentation code *can* be reordered freely: as long as a
34193      VM instruction is counted, the count increment can be placed
34194      anyehere.  Let GCC move this code and possibly achieve better
34195      throughput by exploiting instruction-level parallelism and
34196      therefore approximate more closely a non-profiled build. */
34197   JITTER_PROFILE_COUNT_UPDATE
34198      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34199       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34200 #endif
34201 
34202 /* User-specified code, instruction-beginning-c part: beginning. */
34203 
34204 
34205 /* User-specified code, instruction-beginning-c part: end */
34206 
34207 
34208     /* User code for save-register/%rR . */
34209 
34210     JITTER_PUSH_RETURNSTACK(JITTER_ARG0);
34211 
34212     /* End of the user code for save-register/%rR . */
34213 
34214 /* User-specified code, instruction-end-c part: beginning. */
34215 
34216 
34217 /* User-specified code, instruction-end-c part: end */
34218 
34219     /* Undefine the save-register/%rR argument macros so they can't be used
34220        by mistake in the instruction body coming next. */
34221 #   undef JITTER_SLOW_REGISTER_OFFSET0
34222 #   undef JITTER_ARG0
34223 #   undef JITTER_ARGN0
34224 #   undef JITTER_ARGU0
34225 #   undef JITTER_ARGP0
34226 #   undef JITTER_ARGF0
34227 
34228 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34229 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34230 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34231 
34232   }
34233  JITTER_INSTRUCTION_EPILOG_(save-register/%rR, save_mregister___rrR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34234 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34235 
34236   JITTER_INSTRUCTION_PROLOG_(tail-call/n0, tail_mcall__n0, hot)
34237   {
34238     /* This specialized instruction is not a replacement. */
34239 #   undef JITTER_BRANCH_FAST
34240 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34241 #   undef JITTER_BRANCH_FAST_IF_ZERO
34242 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34243 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34244 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34245 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34246 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34247 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34248 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34249 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34250 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34251 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34252 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34253 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34254 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34255 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34256 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34257 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34258 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34259 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34260 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34261 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34262 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34263 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34264 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34265 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34266 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34267 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34268 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34269 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34270 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34271 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34272 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34273 #   undef JITTER_BRANCH_FAST_IF_AND
34274 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34275 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34276 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34277 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34278 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34279 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34280 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34281 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34282 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34283 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34284 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34285 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34286 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34287 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34288 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34289 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34290 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34291 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34292 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34293 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34294 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34295 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34296 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34297 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34298 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34299 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34300 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34301 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34302 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34303 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       187
34304 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n0
34305 
34306 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n0
34307 
34308   /* The residual arity for this instruction does not depend on fast labels. */
34309   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
34310 
34311     /* The 0th argument is a nonresidual literal. */
34312 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
34313 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34314 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34315 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34316 #   define JITTER_ARGF0 JITTER_ARGP0
34317 
34318 
34319 #if defined (JITTER_PROFILE_SAMPLE)
34320   JITTER_PROFILE_SAMPLE_UPDATE
34321      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34322       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34323   /* Force the compiler not move sample-profiling instrumentation
34324      beyond this point; this way the actual user code is timed.
34325      This is still not perfect, as residuals are materialised before
34326      we arrive here, but should be adequate at least for slow VM
34327      instructions. */
34328   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34329 #endif
34330 #if defined (JITTER_PROFILE_COUNT)
34331   /* Notice that, differently from the code above, this
34332      instrumentation code *can* be reordered freely: as long as a
34333      VM instruction is counted, the count increment can be placed
34334      anyehere.  Let GCC move this code and possibly achieve better
34335      throughput by exploiting instruction-level parallelism and
34336      therefore approximate more closely a non-profiled build. */
34337   JITTER_PROFILE_COUNT_UPDATE
34338      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34339       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34340 #endif
34341 
34342 /* User-specified code, instruction-beginning-c part: beginning. */
34343 
34344 
34345 /* User-specified code, instruction-beginning-c part: end */
34346 
34347 
34348     /* User code for tail-call/n0 . */
34349 
34350     const jitter_uint in_arity = JITTER_ARGN0;
34351     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
34352     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
34353 
34354     if (c->kind == jitterlisp_closure_type_compiled)
34355       {
34356         /* Extract the current return address from the return stack, to be
34357            reused.  Differently from non-tail calls, don't push anything on
34358            the return stack: the callee will overwrite the top with its
34359            current value, which is what we want. */
34360         jitterlispvm_program_point current_link
34361           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
34362 
34363         /* Branch-and-relink to the native code, whose first instruction
34364            will be a prolog. */
34365         struct jitterlisp_compiled_closure *cc = & c->compiled;
34366         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
34367       }
34368     else
34369       {
34370         /* Unfortunately I cannot really tail-call from compiled code to
34371            interpreted code.  Instead I will call the interpreter as a C
34372            function and then return. */
34373         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
34374 
34375         /* Push an element on the main stack.  This way we can ensure that
34376            every actual is accessible thru memory in a contiguous array,
34377            even if the main stack is TOS-optimized.  Compute the address
34378            (on the main stack backing) where the actuals begin.
34379 
34380            Notice that the interpreted function we are calling is allowed
34381            to call into compiled code in its turn.  This is not a problem,
34382            as we are not moving stack pointers down until the call ends:
34383            the unused part of the main and return stacks is available to
34384            the callee. */
34385         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
34386         jitterlisp_object *actuals
34387           // FIXME: add a stack operator to compute this address.
34388           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
34389 
34390         /* Call the interpreter. */
34391         jitterlisp_object interpretation_result
34392           = jitterlisp_call_interpreted (ic, actuals, in_arity);
34393 
34394         /* Remove as many elements as the in-arity plus one (the callee) from
34395            the stack, without affecting the top.  Unless JITTER_ARGN0 is
34396            residual this whole loops compiles to one instruction when the main
34397            stack is TOS-optimized, and doesn't touch memory. */
34398         int i;
34399         for (i = 0; i < in_arity + 1; i ++)
34400           JITTER_NIP_MAINSTACK();
34401 
34402         /* Now the stack is one element higher than it was before the call,
34403            containing the unspecified element at the top.  Replace it with
34404            the result.  Again this doesn't touch memory. */
34405         JITTER_TOP_MAINSTACK() = interpretation_result;
34406 
34407         /* Return to our original caller. */
34408         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
34409         JITTER_DROP_RETURNSTACK();
34410         JITTER_RETURN(return_address);
34411       }
34412 
34413     /* End of the user code for tail-call/n0 . */
34414 
34415 /* User-specified code, instruction-end-c part: beginning. */
34416 
34417 
34418 /* User-specified code, instruction-end-c part: end */
34419 
34420     /* Undefine the tail-call/n0 argument macros so they can't be used
34421        by mistake in the instruction body coming next. */
34422 #   undef JITTER_SLOW_REGISTER_OFFSET0
34423 #   undef JITTER_ARG0
34424 #   undef JITTER_ARGN0
34425 #   undef JITTER_ARGU0
34426 #   undef JITTER_ARGP0
34427 #   undef JITTER_ARGF0
34428 
34429 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34430 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34431 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34432 
34433   }
34434  JITTER_INSTRUCTION_EPILOG_(tail-call/n0, tail_mcall__n0, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34435 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34436 
34437   JITTER_INSTRUCTION_PROLOG_(tail-call/n1, tail_mcall__n1, hot)
34438   {
34439     /* This specialized instruction is not a replacement. */
34440 #   undef JITTER_BRANCH_FAST
34441 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34442 #   undef JITTER_BRANCH_FAST_IF_ZERO
34443 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34444 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34445 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34446 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34447 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34448 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34449 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34450 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34451 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34452 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34453 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34454 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34455 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34456 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34457 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34458 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34459 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34460 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34461 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34462 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34463 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34464 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34465 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34466 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34467 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34468 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34469 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34470 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34471 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34472 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34473 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34474 #   undef JITTER_BRANCH_FAST_IF_AND
34475 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34476 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34477 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34478 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34479 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34480 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34481 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34482 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34483 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34484 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34485 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34486 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34487 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34488 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34489 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34490 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34491 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34492 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34493 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34494 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34495 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34496 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34497 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34498 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34499 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34500 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34501 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34502 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34503 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34504 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       188
34505 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n1
34506 
34507 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n1
34508 
34509   /* The residual arity for this instruction does not depend on fast labels. */
34510   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
34511 
34512     /* The 0th argument is a nonresidual literal. */
34513 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
34514 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34515 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34516 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34517 #   define JITTER_ARGF0 JITTER_ARGP0
34518 
34519 
34520 #if defined (JITTER_PROFILE_SAMPLE)
34521   JITTER_PROFILE_SAMPLE_UPDATE
34522      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34523       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34524   /* Force the compiler not move sample-profiling instrumentation
34525      beyond this point; this way the actual user code is timed.
34526      This is still not perfect, as residuals are materialised before
34527      we arrive here, but should be adequate at least for slow VM
34528      instructions. */
34529   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34530 #endif
34531 #if defined (JITTER_PROFILE_COUNT)
34532   /* Notice that, differently from the code above, this
34533      instrumentation code *can* be reordered freely: as long as a
34534      VM instruction is counted, the count increment can be placed
34535      anyehere.  Let GCC move this code and possibly achieve better
34536      throughput by exploiting instruction-level parallelism and
34537      therefore approximate more closely a non-profiled build. */
34538   JITTER_PROFILE_COUNT_UPDATE
34539      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34540       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34541 #endif
34542 
34543 /* User-specified code, instruction-beginning-c part: beginning. */
34544 
34545 
34546 /* User-specified code, instruction-beginning-c part: end */
34547 
34548 
34549     /* User code for tail-call/n1 . */
34550 
34551     const jitter_uint in_arity = JITTER_ARGN0;
34552     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
34553     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
34554 
34555     if (c->kind == jitterlisp_closure_type_compiled)
34556       {
34557         /* Extract the current return address from the return stack, to be
34558            reused.  Differently from non-tail calls, don't push anything on
34559            the return stack: the callee will overwrite the top with its
34560            current value, which is what we want. */
34561         jitterlispvm_program_point current_link
34562           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
34563 
34564         /* Branch-and-relink to the native code, whose first instruction
34565            will be a prolog. */
34566         struct jitterlisp_compiled_closure *cc = & c->compiled;
34567         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
34568       }
34569     else
34570       {
34571         /* Unfortunately I cannot really tail-call from compiled code to
34572            interpreted code.  Instead I will call the interpreter as a C
34573            function and then return. */
34574         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
34575 
34576         /* Push an element on the main stack.  This way we can ensure that
34577            every actual is accessible thru memory in a contiguous array,
34578            even if the main stack is TOS-optimized.  Compute the address
34579            (on the main stack backing) where the actuals begin.
34580 
34581            Notice that the interpreted function we are calling is allowed
34582            to call into compiled code in its turn.  This is not a problem,
34583            as we are not moving stack pointers down until the call ends:
34584            the unused part of the main and return stacks is available to
34585            the callee. */
34586         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
34587         jitterlisp_object *actuals
34588           // FIXME: add a stack operator to compute this address.
34589           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
34590 
34591         /* Call the interpreter. */
34592         jitterlisp_object interpretation_result
34593           = jitterlisp_call_interpreted (ic, actuals, in_arity);
34594 
34595         /* Remove as many elements as the in-arity plus one (the callee) from
34596            the stack, without affecting the top.  Unless JITTER_ARGN0 is
34597            residual this whole loops compiles to one instruction when the main
34598            stack is TOS-optimized, and doesn't touch memory. */
34599         int i;
34600         for (i = 0; i < in_arity + 1; i ++)
34601           JITTER_NIP_MAINSTACK();
34602 
34603         /* Now the stack is one element higher than it was before the call,
34604            containing the unspecified element at the top.  Replace it with
34605            the result.  Again this doesn't touch memory. */
34606         JITTER_TOP_MAINSTACK() = interpretation_result;
34607 
34608         /* Return to our original caller. */
34609         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
34610         JITTER_DROP_RETURNSTACK();
34611         JITTER_RETURN(return_address);
34612       }
34613 
34614     /* End of the user code for tail-call/n1 . */
34615 
34616 /* User-specified code, instruction-end-c part: beginning. */
34617 
34618 
34619 /* User-specified code, instruction-end-c part: end */
34620 
34621     /* Undefine the tail-call/n1 argument macros so they can't be used
34622        by mistake in the instruction body coming next. */
34623 #   undef JITTER_SLOW_REGISTER_OFFSET0
34624 #   undef JITTER_ARG0
34625 #   undef JITTER_ARGN0
34626 #   undef JITTER_ARGU0
34627 #   undef JITTER_ARGP0
34628 #   undef JITTER_ARGF0
34629 
34630 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34631 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34632 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34633 
34634   }
34635  JITTER_INSTRUCTION_EPILOG_(tail-call/n1, tail_mcall__n1, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34636 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34637 
34638   JITTER_INSTRUCTION_PROLOG_(tail-call/n2, tail_mcall__n2, hot)
34639   {
34640     /* This specialized instruction is not a replacement. */
34641 #   undef JITTER_BRANCH_FAST
34642 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34643 #   undef JITTER_BRANCH_FAST_IF_ZERO
34644 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34645 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34646 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34647 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34648 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34649 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34650 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34651 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34652 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34653 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34654 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34655 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34656 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34657 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34658 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34659 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34660 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34661 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34662 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34663 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34664 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34665 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34666 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34667 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34668 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34669 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34670 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34671 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34672 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34673 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34674 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34675 #   undef JITTER_BRANCH_FAST_IF_AND
34676 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34677 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34678 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34679 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34680 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34681 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34682 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34683 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34684 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34685 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34686 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34687 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34688 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34689 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34690 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34691 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34692 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34693 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34694 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34695 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34696 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34697 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34698 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34699 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34700 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34701 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34702 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34703 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34704 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34705 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       189
34706 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n2
34707 
34708 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n2
34709 
34710   /* The residual arity for this instruction does not depend on fast labels. */
34711   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
34712 
34713     /* The 0th argument is a nonresidual literal. */
34714 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
34715 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34716 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34717 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34718 #   define JITTER_ARGF0 JITTER_ARGP0
34719 
34720 
34721 #if defined (JITTER_PROFILE_SAMPLE)
34722   JITTER_PROFILE_SAMPLE_UPDATE
34723      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34724       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34725   /* Force the compiler not move sample-profiling instrumentation
34726      beyond this point; this way the actual user code is timed.
34727      This is still not perfect, as residuals are materialised before
34728      we arrive here, but should be adequate at least for slow VM
34729      instructions. */
34730   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34731 #endif
34732 #if defined (JITTER_PROFILE_COUNT)
34733   /* Notice that, differently from the code above, this
34734      instrumentation code *can* be reordered freely: as long as a
34735      VM instruction is counted, the count increment can be placed
34736      anyehere.  Let GCC move this code and possibly achieve better
34737      throughput by exploiting instruction-level parallelism and
34738      therefore approximate more closely a non-profiled build. */
34739   JITTER_PROFILE_COUNT_UPDATE
34740      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34741       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34742 #endif
34743 
34744 /* User-specified code, instruction-beginning-c part: beginning. */
34745 
34746 
34747 /* User-specified code, instruction-beginning-c part: end */
34748 
34749 
34750     /* User code for tail-call/n2 . */
34751 
34752     const jitter_uint in_arity = JITTER_ARGN0;
34753     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
34754     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
34755 
34756     if (c->kind == jitterlisp_closure_type_compiled)
34757       {
34758         /* Extract the current return address from the return stack, to be
34759            reused.  Differently from non-tail calls, don't push anything on
34760            the return stack: the callee will overwrite the top with its
34761            current value, which is what we want. */
34762         jitterlispvm_program_point current_link
34763           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
34764 
34765         /* Branch-and-relink to the native code, whose first instruction
34766            will be a prolog. */
34767         struct jitterlisp_compiled_closure *cc = & c->compiled;
34768         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
34769       }
34770     else
34771       {
34772         /* Unfortunately I cannot really tail-call from compiled code to
34773            interpreted code.  Instead I will call the interpreter as a C
34774            function and then return. */
34775         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
34776 
34777         /* Push an element on the main stack.  This way we can ensure that
34778            every actual is accessible thru memory in a contiguous array,
34779            even if the main stack is TOS-optimized.  Compute the address
34780            (on the main stack backing) where the actuals begin.
34781 
34782            Notice that the interpreted function we are calling is allowed
34783            to call into compiled code in its turn.  This is not a problem,
34784            as we are not moving stack pointers down until the call ends:
34785            the unused part of the main and return stacks is available to
34786            the callee. */
34787         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
34788         jitterlisp_object *actuals
34789           // FIXME: add a stack operator to compute this address.
34790           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
34791 
34792         /* Call the interpreter. */
34793         jitterlisp_object interpretation_result
34794           = jitterlisp_call_interpreted (ic, actuals, in_arity);
34795 
34796         /* Remove as many elements as the in-arity plus one (the callee) from
34797            the stack, without affecting the top.  Unless JITTER_ARGN0 is
34798            residual this whole loops compiles to one instruction when the main
34799            stack is TOS-optimized, and doesn't touch memory. */
34800         int i;
34801         for (i = 0; i < in_arity + 1; i ++)
34802           JITTER_NIP_MAINSTACK();
34803 
34804         /* Now the stack is one element higher than it was before the call,
34805            containing the unspecified element at the top.  Replace it with
34806            the result.  Again this doesn't touch memory. */
34807         JITTER_TOP_MAINSTACK() = interpretation_result;
34808 
34809         /* Return to our original caller. */
34810         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
34811         JITTER_DROP_RETURNSTACK();
34812         JITTER_RETURN(return_address);
34813       }
34814 
34815     /* End of the user code for tail-call/n2 . */
34816 
34817 /* User-specified code, instruction-end-c part: beginning. */
34818 
34819 
34820 /* User-specified code, instruction-end-c part: end */
34821 
34822     /* Undefine the tail-call/n2 argument macros so they can't be used
34823        by mistake in the instruction body coming next. */
34824 #   undef JITTER_SLOW_REGISTER_OFFSET0
34825 #   undef JITTER_ARG0
34826 #   undef JITTER_ARGN0
34827 #   undef JITTER_ARGU0
34828 #   undef JITTER_ARGP0
34829 #   undef JITTER_ARGF0
34830 
34831 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
34832 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
34833 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
34834 
34835   }
34836  JITTER_INSTRUCTION_EPILOG_(tail-call/n2, tail_mcall__n2, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
34837 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
34838 
34839   JITTER_INSTRUCTION_PROLOG_(tail-call/n3, tail_mcall__n3, hot)
34840   {
34841     /* This specialized instruction is not a replacement. */
34842 #   undef JITTER_BRANCH_FAST
34843 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
34844 #   undef JITTER_BRANCH_FAST_IF_ZERO
34845 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
34846 #   undef JITTER_BRANCH_FAST_IF_NONZERO
34847 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
34848 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
34849 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
34850 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
34851 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
34852 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
34853 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
34854 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
34855 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
34856 #   undef JITTER_BRANCH_FAST_IF_EQUAL
34857 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
34858 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
34859 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
34860 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
34861 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
34862 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34863 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
34864 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34865 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
34866 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34867 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
34868 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34869 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
34870 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34871 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
34872 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34873 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
34874 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34875 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
34876 #   undef JITTER_BRANCH_FAST_IF_AND
34877 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
34878 #   undef JITTER_BRANCH_FAST_IF_NOTAND
34879 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
34880 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34881 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
34882 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34883 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
34884 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34885 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
34886 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34887 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
34888 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34889 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
34890 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34891 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
34892 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34893 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
34894 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34895 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
34896 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34897 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
34898 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34899 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
34900 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34901 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
34902 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34903 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
34904 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34905 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
34906 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       190
34907 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n3
34908 
34909 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n3
34910 
34911   /* The residual arity for this instruction does not depend on fast labels. */
34912   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
34913 
34914     /* The 0th argument is a nonresidual literal. */
34915 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
34916 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
34917 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
34918 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
34919 #   define JITTER_ARGF0 JITTER_ARGP0
34920 
34921 
34922 #if defined (JITTER_PROFILE_SAMPLE)
34923   JITTER_PROFILE_SAMPLE_UPDATE
34924      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34925       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34926   /* Force the compiler not move sample-profiling instrumentation
34927      beyond this point; this way the actual user code is timed.
34928      This is still not perfect, as residuals are materialised before
34929      we arrive here, but should be adequate at least for slow VM
34930      instructions. */
34931   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
34932 #endif
34933 #if defined (JITTER_PROFILE_COUNT)
34934   /* Notice that, differently from the code above, this
34935      instrumentation code *can* be reordered freely: as long as a
34936      VM instruction is counted, the count increment can be placed
34937      anyehere.  Let GCC move this code and possibly achieve better
34938      throughput by exploiting instruction-level parallelism and
34939      therefore approximate more closely a non-profiled build. */
34940   JITTER_PROFILE_COUNT_UPDATE
34941      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
34942       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
34943 #endif
34944 
34945 /* User-specified code, instruction-beginning-c part: beginning. */
34946 
34947 
34948 /* User-specified code, instruction-beginning-c part: end */
34949 
34950 
34951     /* User code for tail-call/n3 . */
34952 
34953     const jitter_uint in_arity = JITTER_ARGN0;
34954     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
34955     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
34956 
34957     if (c->kind == jitterlisp_closure_type_compiled)
34958       {
34959         /* Extract the current return address from the return stack, to be
34960            reused.  Differently from non-tail calls, don't push anything on
34961            the return stack: the callee will overwrite the top with its
34962            current value, which is what we want. */
34963         jitterlispvm_program_point current_link
34964           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
34965 
34966         /* Branch-and-relink to the native code, whose first instruction
34967            will be a prolog. */
34968         struct jitterlisp_compiled_closure *cc = & c->compiled;
34969         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
34970       }
34971     else
34972       {
34973         /* Unfortunately I cannot really tail-call from compiled code to
34974            interpreted code.  Instead I will call the interpreter as a C
34975            function and then return. */
34976         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
34977 
34978         /* Push an element on the main stack.  This way we can ensure that
34979            every actual is accessible thru memory in a contiguous array,
34980            even if the main stack is TOS-optimized.  Compute the address
34981            (on the main stack backing) where the actuals begin.
34982 
34983            Notice that the interpreted function we are calling is allowed
34984            to call into compiled code in its turn.  This is not a problem,
34985            as we are not moving stack pointers down until the call ends:
34986            the unused part of the main and return stacks is available to
34987            the callee. */
34988         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
34989         jitterlisp_object *actuals
34990           // FIXME: add a stack operator to compute this address.
34991           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
34992 
34993         /* Call the interpreter. */
34994         jitterlisp_object interpretation_result
34995           = jitterlisp_call_interpreted (ic, actuals, in_arity);
34996 
34997         /* Remove as many elements as the in-arity plus one (the callee) from
34998            the stack, without affecting the top.  Unless JITTER_ARGN0 is
34999            residual this whole loops compiles to one instruction when the main
35000            stack is TOS-optimized, and doesn't touch memory. */
35001         int i;
35002         for (i = 0; i < in_arity + 1; i ++)
35003           JITTER_NIP_MAINSTACK();
35004 
35005         /* Now the stack is one element higher than it was before the call,
35006            containing the unspecified element at the top.  Replace it with
35007            the result.  Again this doesn't touch memory. */
35008         JITTER_TOP_MAINSTACK() = interpretation_result;
35009 
35010         /* Return to our original caller. */
35011         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
35012         JITTER_DROP_RETURNSTACK();
35013         JITTER_RETURN(return_address);
35014       }
35015 
35016     /* End of the user code for tail-call/n3 . */
35017 
35018 /* User-specified code, instruction-end-c part: beginning. */
35019 
35020 
35021 /* User-specified code, instruction-end-c part: end */
35022 
35023     /* Undefine the tail-call/n3 argument macros so they can't be used
35024        by mistake in the instruction body coming next. */
35025 #   undef JITTER_SLOW_REGISTER_OFFSET0
35026 #   undef JITTER_ARG0
35027 #   undef JITTER_ARGN0
35028 #   undef JITTER_ARGU0
35029 #   undef JITTER_ARGP0
35030 #   undef JITTER_ARGF0
35031 
35032 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35033 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35034 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35035 
35036   }
35037  JITTER_INSTRUCTION_EPILOG_(tail-call/n3, tail_mcall__n3, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35038 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35039 
35040   JITTER_INSTRUCTION_PROLOG_(tail-call/n4, tail_mcall__n4, hot)
35041   {
35042     /* This specialized instruction is not a replacement. */
35043 #   undef JITTER_BRANCH_FAST
35044 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35045 #   undef JITTER_BRANCH_FAST_IF_ZERO
35046 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35047 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35048 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35049 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35050 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35051 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35052 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35053 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35054 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35055 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35056 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35057 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35058 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35059 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35060 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35061 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35062 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35063 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35064 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35065 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35066 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35067 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35068 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35069 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35070 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35071 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35072 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35073 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35074 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35075 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35076 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35077 #   undef JITTER_BRANCH_FAST_IF_AND
35078 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35079 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35080 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35081 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35082 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35083 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35084 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35085 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35086 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35087 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35088 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35089 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35090 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35091 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35092 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35093 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35094 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35095 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35096 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35097 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35098 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35099 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35100 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35101 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35102 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35103 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35104 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35105 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35106 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35107 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       191
35108 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n4
35109 
35110 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n4
35111 
35112   /* The residual arity for this instruction does not depend on fast labels. */
35113   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35114 
35115     /* The 0th argument is a nonresidual literal. */
35116 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
35117 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
35118 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
35119 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
35120 #   define JITTER_ARGF0 JITTER_ARGP0
35121 
35122 
35123 #if defined (JITTER_PROFILE_SAMPLE)
35124   JITTER_PROFILE_SAMPLE_UPDATE
35125      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35126       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35127   /* Force the compiler not move sample-profiling instrumentation
35128      beyond this point; this way the actual user code is timed.
35129      This is still not perfect, as residuals are materialised before
35130      we arrive here, but should be adequate at least for slow VM
35131      instructions. */
35132   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35133 #endif
35134 #if defined (JITTER_PROFILE_COUNT)
35135   /* Notice that, differently from the code above, this
35136      instrumentation code *can* be reordered freely: as long as a
35137      VM instruction is counted, the count increment can be placed
35138      anyehere.  Let GCC move this code and possibly achieve better
35139      throughput by exploiting instruction-level parallelism and
35140      therefore approximate more closely a non-profiled build. */
35141   JITTER_PROFILE_COUNT_UPDATE
35142      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35143       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35144 #endif
35145 
35146 /* User-specified code, instruction-beginning-c part: beginning. */
35147 
35148 
35149 /* User-specified code, instruction-beginning-c part: end */
35150 
35151 
35152     /* User code for tail-call/n4 . */
35153 
35154     const jitter_uint in_arity = JITTER_ARGN0;
35155     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
35156     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
35157 
35158     if (c->kind == jitterlisp_closure_type_compiled)
35159       {
35160         /* Extract the current return address from the return stack, to be
35161            reused.  Differently from non-tail calls, don't push anything on
35162            the return stack: the callee will overwrite the top with its
35163            current value, which is what we want. */
35164         jitterlispvm_program_point current_link
35165           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
35166 
35167         /* Branch-and-relink to the native code, whose first instruction
35168            will be a prolog. */
35169         struct jitterlisp_compiled_closure *cc = & c->compiled;
35170         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
35171       }
35172     else
35173       {
35174         /* Unfortunately I cannot really tail-call from compiled code to
35175            interpreted code.  Instead I will call the interpreter as a C
35176            function and then return. */
35177         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
35178 
35179         /* Push an element on the main stack.  This way we can ensure that
35180            every actual is accessible thru memory in a contiguous array,
35181            even if the main stack is TOS-optimized.  Compute the address
35182            (on the main stack backing) where the actuals begin.
35183 
35184            Notice that the interpreted function we are calling is allowed
35185            to call into compiled code in its turn.  This is not a problem,
35186            as we are not moving stack pointers down until the call ends:
35187            the unused part of the main and return stacks is available to
35188            the callee. */
35189         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
35190         jitterlisp_object *actuals
35191           // FIXME: add a stack operator to compute this address.
35192           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
35193 
35194         /* Call the interpreter. */
35195         jitterlisp_object interpretation_result
35196           = jitterlisp_call_interpreted (ic, actuals, in_arity);
35197 
35198         /* Remove as many elements as the in-arity plus one (the callee) from
35199            the stack, without affecting the top.  Unless JITTER_ARGN0 is
35200            residual this whole loops compiles to one instruction when the main
35201            stack is TOS-optimized, and doesn't touch memory. */
35202         int i;
35203         for (i = 0; i < in_arity + 1; i ++)
35204           JITTER_NIP_MAINSTACK();
35205 
35206         /* Now the stack is one element higher than it was before the call,
35207            containing the unspecified element at the top.  Replace it with
35208            the result.  Again this doesn't touch memory. */
35209         JITTER_TOP_MAINSTACK() = interpretation_result;
35210 
35211         /* Return to our original caller. */
35212         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
35213         JITTER_DROP_RETURNSTACK();
35214         JITTER_RETURN(return_address);
35215       }
35216 
35217     /* End of the user code for tail-call/n4 . */
35218 
35219 /* User-specified code, instruction-end-c part: beginning. */
35220 
35221 
35222 /* User-specified code, instruction-end-c part: end */
35223 
35224     /* Undefine the tail-call/n4 argument macros so they can't be used
35225        by mistake in the instruction body coming next. */
35226 #   undef JITTER_SLOW_REGISTER_OFFSET0
35227 #   undef JITTER_ARG0
35228 #   undef JITTER_ARGN0
35229 #   undef JITTER_ARGU0
35230 #   undef JITTER_ARGP0
35231 #   undef JITTER_ARGF0
35232 
35233 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35234 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35235 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35236 
35237   }
35238  JITTER_INSTRUCTION_EPILOG_(tail-call/n4, tail_mcall__n4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35239 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35240 
35241   JITTER_INSTRUCTION_PROLOG_(tail-call/n5, tail_mcall__n5, hot)
35242   {
35243     /* This specialized instruction is not a replacement. */
35244 #   undef JITTER_BRANCH_FAST
35245 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35246 #   undef JITTER_BRANCH_FAST_IF_ZERO
35247 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35248 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35249 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35250 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35251 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35252 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35253 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35254 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35255 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35256 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35257 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35258 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35259 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35260 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35261 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35262 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35263 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35264 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35265 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35266 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35267 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35268 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35269 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35270 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35271 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35272 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35273 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35274 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35275 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35276 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35277 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35278 #   undef JITTER_BRANCH_FAST_IF_AND
35279 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35280 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35281 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35282 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35283 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35284 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35285 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35286 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35287 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35288 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35289 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35290 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35291 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35292 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35293 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35294 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35295 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35296 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35297 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35298 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35299 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35300 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35301 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35302 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35303 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35304 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35305 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35306 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35307 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35308 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       192
35309 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n5
35310 
35311 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n5
35312 
35313   /* The residual arity for this instruction does not depend on fast labels. */
35314   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35315 
35316     /* The 0th argument is a nonresidual literal. */
35317 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
35318 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
35319 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
35320 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
35321 #   define JITTER_ARGF0 JITTER_ARGP0
35322 
35323 
35324 #if defined (JITTER_PROFILE_SAMPLE)
35325   JITTER_PROFILE_SAMPLE_UPDATE
35326      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35327       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35328   /* Force the compiler not move sample-profiling instrumentation
35329      beyond this point; this way the actual user code is timed.
35330      This is still not perfect, as residuals are materialised before
35331      we arrive here, but should be adequate at least for slow VM
35332      instructions. */
35333   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35334 #endif
35335 #if defined (JITTER_PROFILE_COUNT)
35336   /* Notice that, differently from the code above, this
35337      instrumentation code *can* be reordered freely: as long as a
35338      VM instruction is counted, the count increment can be placed
35339      anyehere.  Let GCC move this code and possibly achieve better
35340      throughput by exploiting instruction-level parallelism and
35341      therefore approximate more closely a non-profiled build. */
35342   JITTER_PROFILE_COUNT_UPDATE
35343      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35344       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35345 #endif
35346 
35347 /* User-specified code, instruction-beginning-c part: beginning. */
35348 
35349 
35350 /* User-specified code, instruction-beginning-c part: end */
35351 
35352 
35353     /* User code for tail-call/n5 . */
35354 
35355     const jitter_uint in_arity = JITTER_ARGN0;
35356     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
35357     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
35358 
35359     if (c->kind == jitterlisp_closure_type_compiled)
35360       {
35361         /* Extract the current return address from the return stack, to be
35362            reused.  Differently from non-tail calls, don't push anything on
35363            the return stack: the callee will overwrite the top with its
35364            current value, which is what we want. */
35365         jitterlispvm_program_point current_link
35366           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
35367 
35368         /* Branch-and-relink to the native code, whose first instruction
35369            will be a prolog. */
35370         struct jitterlisp_compiled_closure *cc = & c->compiled;
35371         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
35372       }
35373     else
35374       {
35375         /* Unfortunately I cannot really tail-call from compiled code to
35376            interpreted code.  Instead I will call the interpreter as a C
35377            function and then return. */
35378         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
35379 
35380         /* Push an element on the main stack.  This way we can ensure that
35381            every actual is accessible thru memory in a contiguous array,
35382            even if the main stack is TOS-optimized.  Compute the address
35383            (on the main stack backing) where the actuals begin.
35384 
35385            Notice that the interpreted function we are calling is allowed
35386            to call into compiled code in its turn.  This is not a problem,
35387            as we are not moving stack pointers down until the call ends:
35388            the unused part of the main and return stacks is available to
35389            the callee. */
35390         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
35391         jitterlisp_object *actuals
35392           // FIXME: add a stack operator to compute this address.
35393           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
35394 
35395         /* Call the interpreter. */
35396         jitterlisp_object interpretation_result
35397           = jitterlisp_call_interpreted (ic, actuals, in_arity);
35398 
35399         /* Remove as many elements as the in-arity plus one (the callee) from
35400            the stack, without affecting the top.  Unless JITTER_ARGN0 is
35401            residual this whole loops compiles to one instruction when the main
35402            stack is TOS-optimized, and doesn't touch memory. */
35403         int i;
35404         for (i = 0; i < in_arity + 1; i ++)
35405           JITTER_NIP_MAINSTACK();
35406 
35407         /* Now the stack is one element higher than it was before the call,
35408            containing the unspecified element at the top.  Replace it with
35409            the result.  Again this doesn't touch memory. */
35410         JITTER_TOP_MAINSTACK() = interpretation_result;
35411 
35412         /* Return to our original caller. */
35413         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
35414         JITTER_DROP_RETURNSTACK();
35415         JITTER_RETURN(return_address);
35416       }
35417 
35418     /* End of the user code for tail-call/n5 . */
35419 
35420 /* User-specified code, instruction-end-c part: beginning. */
35421 
35422 
35423 /* User-specified code, instruction-end-c part: end */
35424 
35425     /* Undefine the tail-call/n5 argument macros so they can't be used
35426        by mistake in the instruction body coming next. */
35427 #   undef JITTER_SLOW_REGISTER_OFFSET0
35428 #   undef JITTER_ARG0
35429 #   undef JITTER_ARGN0
35430 #   undef JITTER_ARGU0
35431 #   undef JITTER_ARGP0
35432 #   undef JITTER_ARGF0
35433 
35434 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35435 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35436 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35437 
35438   }
35439  JITTER_INSTRUCTION_EPILOG_(tail-call/n5, tail_mcall__n5, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35440 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35441 
35442   JITTER_INSTRUCTION_PROLOG_(tail-call/n6, tail_mcall__n6, hot)
35443   {
35444     /* This specialized instruction is not a replacement. */
35445 #   undef JITTER_BRANCH_FAST
35446 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35447 #   undef JITTER_BRANCH_FAST_IF_ZERO
35448 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35449 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35450 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35451 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35452 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35453 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35454 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35455 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35456 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35457 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35458 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35459 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35460 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35461 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35462 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35463 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35464 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35465 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35466 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35467 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35468 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35469 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35470 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35471 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35472 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35473 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35474 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35475 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35476 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35477 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35478 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35479 #   undef JITTER_BRANCH_FAST_IF_AND
35480 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35481 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35482 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35483 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35484 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35485 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35486 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35487 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35488 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35489 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35490 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35491 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35492 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35493 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35494 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35495 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35496 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35497 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35498 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35499 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35500 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35501 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35502 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35503 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35504 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35505 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35506 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35507 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35508 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35509 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       193
35510 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n6
35511 
35512 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n6
35513 
35514   /* The residual arity for this instruction does not depend on fast labels. */
35515   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35516 
35517     /* The 0th argument is a nonresidual literal. */
35518 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
35519 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
35520 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
35521 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
35522 #   define JITTER_ARGF0 JITTER_ARGP0
35523 
35524 
35525 #if defined (JITTER_PROFILE_SAMPLE)
35526   JITTER_PROFILE_SAMPLE_UPDATE
35527      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35528       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35529   /* Force the compiler not move sample-profiling instrumentation
35530      beyond this point; this way the actual user code is timed.
35531      This is still not perfect, as residuals are materialised before
35532      we arrive here, but should be adequate at least for slow VM
35533      instructions. */
35534   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35535 #endif
35536 #if defined (JITTER_PROFILE_COUNT)
35537   /* Notice that, differently from the code above, this
35538      instrumentation code *can* be reordered freely: as long as a
35539      VM instruction is counted, the count increment can be placed
35540      anyehere.  Let GCC move this code and possibly achieve better
35541      throughput by exploiting instruction-level parallelism and
35542      therefore approximate more closely a non-profiled build. */
35543   JITTER_PROFILE_COUNT_UPDATE
35544      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35545       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35546 #endif
35547 
35548 /* User-specified code, instruction-beginning-c part: beginning. */
35549 
35550 
35551 /* User-specified code, instruction-beginning-c part: end */
35552 
35553 
35554     /* User code for tail-call/n6 . */
35555 
35556     const jitter_uint in_arity = JITTER_ARGN0;
35557     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
35558     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
35559 
35560     if (c->kind == jitterlisp_closure_type_compiled)
35561       {
35562         /* Extract the current return address from the return stack, to be
35563            reused.  Differently from non-tail calls, don't push anything on
35564            the return stack: the callee will overwrite the top with its
35565            current value, which is what we want. */
35566         jitterlispvm_program_point current_link
35567           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
35568 
35569         /* Branch-and-relink to the native code, whose first instruction
35570            will be a prolog. */
35571         struct jitterlisp_compiled_closure *cc = & c->compiled;
35572         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
35573       }
35574     else
35575       {
35576         /* Unfortunately I cannot really tail-call from compiled code to
35577            interpreted code.  Instead I will call the interpreter as a C
35578            function and then return. */
35579         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
35580 
35581         /* Push an element on the main stack.  This way we can ensure that
35582            every actual is accessible thru memory in a contiguous array,
35583            even if the main stack is TOS-optimized.  Compute the address
35584            (on the main stack backing) where the actuals begin.
35585 
35586            Notice that the interpreted function we are calling is allowed
35587            to call into compiled code in its turn.  This is not a problem,
35588            as we are not moving stack pointers down until the call ends:
35589            the unused part of the main and return stacks is available to
35590            the callee. */
35591         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
35592         jitterlisp_object *actuals
35593           // FIXME: add a stack operator to compute this address.
35594           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
35595 
35596         /* Call the interpreter. */
35597         jitterlisp_object interpretation_result
35598           = jitterlisp_call_interpreted (ic, actuals, in_arity);
35599 
35600         /* Remove as many elements as the in-arity plus one (the callee) from
35601            the stack, without affecting the top.  Unless JITTER_ARGN0 is
35602            residual this whole loops compiles to one instruction when the main
35603            stack is TOS-optimized, and doesn't touch memory. */
35604         int i;
35605         for (i = 0; i < in_arity + 1; i ++)
35606           JITTER_NIP_MAINSTACK();
35607 
35608         /* Now the stack is one element higher than it was before the call,
35609            containing the unspecified element at the top.  Replace it with
35610            the result.  Again this doesn't touch memory. */
35611         JITTER_TOP_MAINSTACK() = interpretation_result;
35612 
35613         /* Return to our original caller. */
35614         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
35615         JITTER_DROP_RETURNSTACK();
35616         JITTER_RETURN(return_address);
35617       }
35618 
35619     /* End of the user code for tail-call/n6 . */
35620 
35621 /* User-specified code, instruction-end-c part: beginning. */
35622 
35623 
35624 /* User-specified code, instruction-end-c part: end */
35625 
35626     /* Undefine the tail-call/n6 argument macros so they can't be used
35627        by mistake in the instruction body coming next. */
35628 #   undef JITTER_SLOW_REGISTER_OFFSET0
35629 #   undef JITTER_ARG0
35630 #   undef JITTER_ARGN0
35631 #   undef JITTER_ARGU0
35632 #   undef JITTER_ARGP0
35633 #   undef JITTER_ARGF0
35634 
35635 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35636 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35637 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35638 
35639   }
35640  JITTER_INSTRUCTION_EPILOG_(tail-call/n6, tail_mcall__n6, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35641 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35642 
35643   JITTER_INSTRUCTION_PROLOG_(tail-call/n7, tail_mcall__n7, hot)
35644   {
35645     /* This specialized instruction is not a replacement. */
35646 #   undef JITTER_BRANCH_FAST
35647 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35648 #   undef JITTER_BRANCH_FAST_IF_ZERO
35649 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35650 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35651 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35652 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35653 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35654 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35655 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35656 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35657 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35658 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35659 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35660 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35661 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35662 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35663 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35664 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35665 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35666 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35667 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35668 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35669 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35670 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35671 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35672 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35673 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35674 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35675 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35676 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35677 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35678 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35679 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35680 #   undef JITTER_BRANCH_FAST_IF_AND
35681 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35682 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35683 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35684 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35685 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35686 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35687 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35688 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35689 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35690 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35691 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35692 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35693 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35694 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35695 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35696 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35697 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35698 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35699 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35700 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35701 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35702 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35703 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35704 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35705 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35706 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35707 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35708 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35709 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35710 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       194
35711 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n7
35712 
35713 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n7
35714 
35715   /* The residual arity for this instruction does not depend on fast labels. */
35716   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35717 
35718     /* The 0th argument is a nonresidual literal. */
35719 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
35720 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
35721 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
35722 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
35723 #   define JITTER_ARGF0 JITTER_ARGP0
35724 
35725 
35726 #if defined (JITTER_PROFILE_SAMPLE)
35727   JITTER_PROFILE_SAMPLE_UPDATE
35728      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35729       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35730   /* Force the compiler not move sample-profiling instrumentation
35731      beyond this point; this way the actual user code is timed.
35732      This is still not perfect, as residuals are materialised before
35733      we arrive here, but should be adequate at least for slow VM
35734      instructions. */
35735   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35736 #endif
35737 #if defined (JITTER_PROFILE_COUNT)
35738   /* Notice that, differently from the code above, this
35739      instrumentation code *can* be reordered freely: as long as a
35740      VM instruction is counted, the count increment can be placed
35741      anyehere.  Let GCC move this code and possibly achieve better
35742      throughput by exploiting instruction-level parallelism and
35743      therefore approximate more closely a non-profiled build. */
35744   JITTER_PROFILE_COUNT_UPDATE
35745      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35746       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35747 #endif
35748 
35749 /* User-specified code, instruction-beginning-c part: beginning. */
35750 
35751 
35752 /* User-specified code, instruction-beginning-c part: end */
35753 
35754 
35755     /* User code for tail-call/n7 . */
35756 
35757     const jitter_uint in_arity = JITTER_ARGN0;
35758     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
35759     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
35760 
35761     if (c->kind == jitterlisp_closure_type_compiled)
35762       {
35763         /* Extract the current return address from the return stack, to be
35764            reused.  Differently from non-tail calls, don't push anything on
35765            the return stack: the callee will overwrite the top with its
35766            current value, which is what we want. */
35767         jitterlispvm_program_point current_link
35768           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
35769 
35770         /* Branch-and-relink to the native code, whose first instruction
35771            will be a prolog. */
35772         struct jitterlisp_compiled_closure *cc = & c->compiled;
35773         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
35774       }
35775     else
35776       {
35777         /* Unfortunately I cannot really tail-call from compiled code to
35778            interpreted code.  Instead I will call the interpreter as a C
35779            function and then return. */
35780         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
35781 
35782         /* Push an element on the main stack.  This way we can ensure that
35783            every actual is accessible thru memory in a contiguous array,
35784            even if the main stack is TOS-optimized.  Compute the address
35785            (on the main stack backing) where the actuals begin.
35786 
35787            Notice that the interpreted function we are calling is allowed
35788            to call into compiled code in its turn.  This is not a problem,
35789            as we are not moving stack pointers down until the call ends:
35790            the unused part of the main and return stacks is available to
35791            the callee. */
35792         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
35793         jitterlisp_object *actuals
35794           // FIXME: add a stack operator to compute this address.
35795           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
35796 
35797         /* Call the interpreter. */
35798         jitterlisp_object interpretation_result
35799           = jitterlisp_call_interpreted (ic, actuals, in_arity);
35800 
35801         /* Remove as many elements as the in-arity plus one (the callee) from
35802            the stack, without affecting the top.  Unless JITTER_ARGN0 is
35803            residual this whole loops compiles to one instruction when the main
35804            stack is TOS-optimized, and doesn't touch memory. */
35805         int i;
35806         for (i = 0; i < in_arity + 1; i ++)
35807           JITTER_NIP_MAINSTACK();
35808 
35809         /* Now the stack is one element higher than it was before the call,
35810            containing the unspecified element at the top.  Replace it with
35811            the result.  Again this doesn't touch memory. */
35812         JITTER_TOP_MAINSTACK() = interpretation_result;
35813 
35814         /* Return to our original caller. */
35815         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
35816         JITTER_DROP_RETURNSTACK();
35817         JITTER_RETURN(return_address);
35818       }
35819 
35820     /* End of the user code for tail-call/n7 . */
35821 
35822 /* User-specified code, instruction-end-c part: beginning. */
35823 
35824 
35825 /* User-specified code, instruction-end-c part: end */
35826 
35827     /* Undefine the tail-call/n7 argument macros so they can't be used
35828        by mistake in the instruction body coming next. */
35829 #   undef JITTER_SLOW_REGISTER_OFFSET0
35830 #   undef JITTER_ARG0
35831 #   undef JITTER_ARGN0
35832 #   undef JITTER_ARGU0
35833 #   undef JITTER_ARGP0
35834 #   undef JITTER_ARGF0
35835 
35836 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
35837 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
35838 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
35839 
35840   }
35841  JITTER_INSTRUCTION_EPILOG_(tail-call/n7, tail_mcall__n7, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
35842 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
35843 
35844   JITTER_INSTRUCTION_PROLOG_(tail-call/n8, tail_mcall__n8, hot)
35845   {
35846     /* This specialized instruction is not a replacement. */
35847 #   undef JITTER_BRANCH_FAST
35848 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
35849 #   undef JITTER_BRANCH_FAST_IF_ZERO
35850 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
35851 #   undef JITTER_BRANCH_FAST_IF_NONZERO
35852 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
35853 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
35854 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
35855 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
35856 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
35857 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
35858 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
35859 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
35860 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
35861 #   undef JITTER_BRANCH_FAST_IF_EQUAL
35862 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
35863 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
35864 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
35865 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
35866 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
35867 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35868 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
35869 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35870 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
35871 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35872 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
35873 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35874 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
35875 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35876 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
35877 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35878 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
35879 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35880 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
35881 #   undef JITTER_BRANCH_FAST_IF_AND
35882 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
35883 #   undef JITTER_BRANCH_FAST_IF_NOTAND
35884 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
35885 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35886 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
35887 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35888 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
35889 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35890 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
35891 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35892 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
35893 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35894 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
35895 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35896 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
35897 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35898 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
35899 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35900 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
35901 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35902 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
35903 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35904 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
35905 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35906 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
35907 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35908 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
35909 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35910 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
35911 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       195
35912 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n8
35913 
35914 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n8
35915 
35916   /* The residual arity for this instruction does not depend on fast labels. */
35917   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
35918 
35919     /* The 0th argument is a nonresidual literal. */
35920 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
35921 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
35922 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
35923 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
35924 #   define JITTER_ARGF0 JITTER_ARGP0
35925 
35926 
35927 #if defined (JITTER_PROFILE_SAMPLE)
35928   JITTER_PROFILE_SAMPLE_UPDATE
35929      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35930       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35931   /* Force the compiler not move sample-profiling instrumentation
35932      beyond this point; this way the actual user code is timed.
35933      This is still not perfect, as residuals are materialised before
35934      we arrive here, but should be adequate at least for slow VM
35935      instructions. */
35936   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
35937 #endif
35938 #if defined (JITTER_PROFILE_COUNT)
35939   /* Notice that, differently from the code above, this
35940      instrumentation code *can* be reordered freely: as long as a
35941      VM instruction is counted, the count increment can be placed
35942      anyehere.  Let GCC move this code and possibly achieve better
35943      throughput by exploiting instruction-level parallelism and
35944      therefore approximate more closely a non-profiled build. */
35945   JITTER_PROFILE_COUNT_UPDATE
35946      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
35947       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
35948 #endif
35949 
35950 /* User-specified code, instruction-beginning-c part: beginning. */
35951 
35952 
35953 /* User-specified code, instruction-beginning-c part: end */
35954 
35955 
35956     /* User code for tail-call/n8 . */
35957 
35958     const jitter_uint in_arity = JITTER_ARGN0;
35959     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
35960     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
35961 
35962     if (c->kind == jitterlisp_closure_type_compiled)
35963       {
35964         /* Extract the current return address from the return stack, to be
35965            reused.  Differently from non-tail calls, don't push anything on
35966            the return stack: the callee will overwrite the top with its
35967            current value, which is what we want. */
35968         jitterlispvm_program_point current_link
35969           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
35970 
35971         /* Branch-and-relink to the native code, whose first instruction
35972            will be a prolog. */
35973         struct jitterlisp_compiled_closure *cc = & c->compiled;
35974         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
35975       }
35976     else
35977       {
35978         /* Unfortunately I cannot really tail-call from compiled code to
35979            interpreted code.  Instead I will call the interpreter as a C
35980            function and then return. */
35981         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
35982 
35983         /* Push an element on the main stack.  This way we can ensure that
35984            every actual is accessible thru memory in a contiguous array,
35985            even if the main stack is TOS-optimized.  Compute the address
35986            (on the main stack backing) where the actuals begin.
35987 
35988            Notice that the interpreted function we are calling is allowed
35989            to call into compiled code in its turn.  This is not a problem,
35990            as we are not moving stack pointers down until the call ends:
35991            the unused part of the main and return stacks is available to
35992            the callee. */
35993         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
35994         jitterlisp_object *actuals
35995           // FIXME: add a stack operator to compute this address.
35996           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
35997 
35998         /* Call the interpreter. */
35999         jitterlisp_object interpretation_result
36000           = jitterlisp_call_interpreted (ic, actuals, in_arity);
36001 
36002         /* Remove as many elements as the in-arity plus one (the callee) from
36003            the stack, without affecting the top.  Unless JITTER_ARGN0 is
36004            residual this whole loops compiles to one instruction when the main
36005            stack is TOS-optimized, and doesn't touch memory. */
36006         int i;
36007         for (i = 0; i < in_arity + 1; i ++)
36008           JITTER_NIP_MAINSTACK();
36009 
36010         /* Now the stack is one element higher than it was before the call,
36011            containing the unspecified element at the top.  Replace it with
36012            the result.  Again this doesn't touch memory. */
36013         JITTER_TOP_MAINSTACK() = interpretation_result;
36014 
36015         /* Return to our original caller. */
36016         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
36017         JITTER_DROP_RETURNSTACK();
36018         JITTER_RETURN(return_address);
36019       }
36020 
36021     /* End of the user code for tail-call/n8 . */
36022 
36023 /* User-specified code, instruction-end-c part: beginning. */
36024 
36025 
36026 /* User-specified code, instruction-end-c part: end */
36027 
36028     /* Undefine the tail-call/n8 argument macros so they can't be used
36029        by mistake in the instruction body coming next. */
36030 #   undef JITTER_SLOW_REGISTER_OFFSET0
36031 #   undef JITTER_ARG0
36032 #   undef JITTER_ARGN0
36033 #   undef JITTER_ARGU0
36034 #   undef JITTER_ARGP0
36035 #   undef JITTER_ARGF0
36036 
36037 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36038 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36039 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36040 
36041   }
36042  JITTER_INSTRUCTION_EPILOG_(tail-call/n8, tail_mcall__n8, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36043 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36044 
36045   JITTER_INSTRUCTION_PROLOG_(tail-call/n9, tail_mcall__n9, hot)
36046   {
36047     /* This specialized instruction is not a replacement. */
36048 #   undef JITTER_BRANCH_FAST
36049 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36050 #   undef JITTER_BRANCH_FAST_IF_ZERO
36051 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36052 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36053 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36054 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36055 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36056 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36057 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36058 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36059 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36060 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36061 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36062 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36063 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36064 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36065 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36066 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36067 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36068 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36069 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36070 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36071 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36072 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36073 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36074 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36075 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36076 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36077 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36078 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36079 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36080 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36081 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36082 #   undef JITTER_BRANCH_FAST_IF_AND
36083 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36084 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36085 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36086 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36087 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36088 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36089 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36090 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36091 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36092 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36093 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36094 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36095 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36096 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36097 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36098 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36099 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36100 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36101 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36102 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36103 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36104 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36105 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36106 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36107 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36108 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36109 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36110 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36111 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36112 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       196
36113 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n9
36114 
36115 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n9
36116 
36117   /* The residual arity for this instruction does not depend on fast labels. */
36118   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36119 
36120     /* The 0th argument is a nonresidual literal. */
36121 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
36122 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36123 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36124 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36125 #   define JITTER_ARGF0 JITTER_ARGP0
36126 
36127 
36128 #if defined (JITTER_PROFILE_SAMPLE)
36129   JITTER_PROFILE_SAMPLE_UPDATE
36130      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36131       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36132   /* Force the compiler not move sample-profiling instrumentation
36133      beyond this point; this way the actual user code is timed.
36134      This is still not perfect, as residuals are materialised before
36135      we arrive here, but should be adequate at least for slow VM
36136      instructions. */
36137   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36138 #endif
36139 #if defined (JITTER_PROFILE_COUNT)
36140   /* Notice that, differently from the code above, this
36141      instrumentation code *can* be reordered freely: as long as a
36142      VM instruction is counted, the count increment can be placed
36143      anyehere.  Let GCC move this code and possibly achieve better
36144      throughput by exploiting instruction-level parallelism and
36145      therefore approximate more closely a non-profiled build. */
36146   JITTER_PROFILE_COUNT_UPDATE
36147      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36148       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36149 #endif
36150 
36151 /* User-specified code, instruction-beginning-c part: beginning. */
36152 
36153 
36154 /* User-specified code, instruction-beginning-c part: end */
36155 
36156 
36157     /* User code for tail-call/n9 . */
36158 
36159     const jitter_uint in_arity = JITTER_ARGN0;
36160     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
36161     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
36162 
36163     if (c->kind == jitterlisp_closure_type_compiled)
36164       {
36165         /* Extract the current return address from the return stack, to be
36166            reused.  Differently from non-tail calls, don't push anything on
36167            the return stack: the callee will overwrite the top with its
36168            current value, which is what we want. */
36169         jitterlispvm_program_point current_link
36170           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
36171 
36172         /* Branch-and-relink to the native code, whose first instruction
36173            will be a prolog. */
36174         struct jitterlisp_compiled_closure *cc = & c->compiled;
36175         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
36176       }
36177     else
36178       {
36179         /* Unfortunately I cannot really tail-call from compiled code to
36180            interpreted code.  Instead I will call the interpreter as a C
36181            function and then return. */
36182         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
36183 
36184         /* Push an element on the main stack.  This way we can ensure that
36185            every actual is accessible thru memory in a contiguous array,
36186            even if the main stack is TOS-optimized.  Compute the address
36187            (on the main stack backing) where the actuals begin.
36188 
36189            Notice that the interpreted function we are calling is allowed
36190            to call into compiled code in its turn.  This is not a problem,
36191            as we are not moving stack pointers down until the call ends:
36192            the unused part of the main and return stacks is available to
36193            the callee. */
36194         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
36195         jitterlisp_object *actuals
36196           // FIXME: add a stack operator to compute this address.
36197           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
36198 
36199         /* Call the interpreter. */
36200         jitterlisp_object interpretation_result
36201           = jitterlisp_call_interpreted (ic, actuals, in_arity);
36202 
36203         /* Remove as many elements as the in-arity plus one (the callee) from
36204            the stack, without affecting the top.  Unless JITTER_ARGN0 is
36205            residual this whole loops compiles to one instruction when the main
36206            stack is TOS-optimized, and doesn't touch memory. */
36207         int i;
36208         for (i = 0; i < in_arity + 1; i ++)
36209           JITTER_NIP_MAINSTACK();
36210 
36211         /* Now the stack is one element higher than it was before the call,
36212            containing the unspecified element at the top.  Replace it with
36213            the result.  Again this doesn't touch memory. */
36214         JITTER_TOP_MAINSTACK() = interpretation_result;
36215 
36216         /* Return to our original caller. */
36217         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
36218         JITTER_DROP_RETURNSTACK();
36219         JITTER_RETURN(return_address);
36220       }
36221 
36222     /* End of the user code for tail-call/n9 . */
36223 
36224 /* User-specified code, instruction-end-c part: beginning. */
36225 
36226 
36227 /* User-specified code, instruction-end-c part: end */
36228 
36229     /* Undefine the tail-call/n9 argument macros so they can't be used
36230        by mistake in the instruction body coming next. */
36231 #   undef JITTER_SLOW_REGISTER_OFFSET0
36232 #   undef JITTER_ARG0
36233 #   undef JITTER_ARGN0
36234 #   undef JITTER_ARGU0
36235 #   undef JITTER_ARGP0
36236 #   undef JITTER_ARGF0
36237 
36238 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36239 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36240 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36241 
36242   }
36243  JITTER_INSTRUCTION_EPILOG_(tail-call/n9, tail_mcall__n9, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36244 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36245 
36246   JITTER_INSTRUCTION_PROLOG_(tail-call/n10, tail_mcall__n10, hot)
36247   {
36248     /* This specialized instruction is not a replacement. */
36249 #   undef JITTER_BRANCH_FAST
36250 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36251 #   undef JITTER_BRANCH_FAST_IF_ZERO
36252 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36253 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36254 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36255 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36256 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36257 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36258 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36259 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36260 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36261 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36262 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36263 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36264 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36265 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36266 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36267 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36268 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36269 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36270 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36271 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36272 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36273 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36274 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36275 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36276 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36277 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36278 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36279 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36280 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36281 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36282 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36283 #   undef JITTER_BRANCH_FAST_IF_AND
36284 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36285 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36286 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36287 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36288 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36289 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36290 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36291 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36292 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36293 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36294 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36295 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36296 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36297 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36298 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36299 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36300 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36301 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36302 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36303 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36304 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36305 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36306 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36307 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36308 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36309 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36310 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36311 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36312 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36313 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       197
36314 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/n10
36315 
36316 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__n10
36317 
36318   /* The residual arity for this instruction does not depend on fast labels. */
36319   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36320 
36321     /* The 0th argument is a nonresidual literal. */
36322 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
36323 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36324 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36325 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36326 #   define JITTER_ARGF0 JITTER_ARGP0
36327 
36328 
36329 #if defined (JITTER_PROFILE_SAMPLE)
36330   JITTER_PROFILE_SAMPLE_UPDATE
36331      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36332       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36333   /* Force the compiler not move sample-profiling instrumentation
36334      beyond this point; this way the actual user code is timed.
36335      This is still not perfect, as residuals are materialised before
36336      we arrive here, but should be adequate at least for slow VM
36337      instructions. */
36338   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36339 #endif
36340 #if defined (JITTER_PROFILE_COUNT)
36341   /* Notice that, differently from the code above, this
36342      instrumentation code *can* be reordered freely: as long as a
36343      VM instruction is counted, the count increment can be placed
36344      anyehere.  Let GCC move this code and possibly achieve better
36345      throughput by exploiting instruction-level parallelism and
36346      therefore approximate more closely a non-profiled build. */
36347   JITTER_PROFILE_COUNT_UPDATE
36348      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36349       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36350 #endif
36351 
36352 /* User-specified code, instruction-beginning-c part: beginning. */
36353 
36354 
36355 /* User-specified code, instruction-beginning-c part: end */
36356 
36357 
36358     /* User code for tail-call/n10 . */
36359 
36360     const jitter_uint in_arity = JITTER_ARGN0;
36361     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
36362     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
36363 
36364     if (c->kind == jitterlisp_closure_type_compiled)
36365       {
36366         /* Extract the current return address from the return stack, to be
36367            reused.  Differently from non-tail calls, don't push anything on
36368            the return stack: the callee will overwrite the top with its
36369            current value, which is what we want. */
36370         jitterlispvm_program_point current_link
36371           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
36372 
36373         /* Branch-and-relink to the native code, whose first instruction
36374            will be a prolog. */
36375         struct jitterlisp_compiled_closure *cc = & c->compiled;
36376         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
36377       }
36378     else
36379       {
36380         /* Unfortunately I cannot really tail-call from compiled code to
36381            interpreted code.  Instead I will call the interpreter as a C
36382            function and then return. */
36383         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
36384 
36385         /* Push an element on the main stack.  This way we can ensure that
36386            every actual is accessible thru memory in a contiguous array,
36387            even if the main stack is TOS-optimized.  Compute the address
36388            (on the main stack backing) where the actuals begin.
36389 
36390            Notice that the interpreted function we are calling is allowed
36391            to call into compiled code in its turn.  This is not a problem,
36392            as we are not moving stack pointers down until the call ends:
36393            the unused part of the main and return stacks is available to
36394            the callee. */
36395         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
36396         jitterlisp_object *actuals
36397           // FIXME: add a stack operator to compute this address.
36398           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
36399 
36400         /* Call the interpreter. */
36401         jitterlisp_object interpretation_result
36402           = jitterlisp_call_interpreted (ic, actuals, in_arity);
36403 
36404         /* Remove as many elements as the in-arity plus one (the callee) from
36405            the stack, without affecting the top.  Unless JITTER_ARGN0 is
36406            residual this whole loops compiles to one instruction when the main
36407            stack is TOS-optimized, and doesn't touch memory. */
36408         int i;
36409         for (i = 0; i < in_arity + 1; i ++)
36410           JITTER_NIP_MAINSTACK();
36411 
36412         /* Now the stack is one element higher than it was before the call,
36413            containing the unspecified element at the top.  Replace it with
36414            the result.  Again this doesn't touch memory. */
36415         JITTER_TOP_MAINSTACK() = interpretation_result;
36416 
36417         /* Return to our original caller. */
36418         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
36419         JITTER_DROP_RETURNSTACK();
36420         JITTER_RETURN(return_address);
36421       }
36422 
36423     /* End of the user code for tail-call/n10 . */
36424 
36425 /* User-specified code, instruction-end-c part: beginning. */
36426 
36427 
36428 /* User-specified code, instruction-end-c part: end */
36429 
36430     /* Undefine the tail-call/n10 argument macros so they can't be used
36431        by mistake in the instruction body coming next. */
36432 #   undef JITTER_SLOW_REGISTER_OFFSET0
36433 #   undef JITTER_ARG0
36434 #   undef JITTER_ARGN0
36435 #   undef JITTER_ARGU0
36436 #   undef JITTER_ARGP0
36437 #   undef JITTER_ARGF0
36438 
36439 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36440 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36441 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36442 
36443   }
36444  JITTER_INSTRUCTION_EPILOG_(tail-call/n10, tail_mcall__n10, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36445 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36446 
36447   JITTER_INSTRUCTION_PROLOG_(tail-call/nR, tail_mcall__nR, cold)
36448   {
36449     /* This specialized instruction is not a replacement. */
36450 #   undef JITTER_BRANCH_FAST
36451 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36452 #   undef JITTER_BRANCH_FAST_IF_ZERO
36453 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36454 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36455 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36456 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36457 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36458 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36459 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36460 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36461 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36462 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36463 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36464 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36465 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36466 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36467 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36468 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36469 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36470 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36471 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36472 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36473 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36474 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36475 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36476 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36477 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36478 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36479 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36480 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36481 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36482 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36483 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36484 #   undef JITTER_BRANCH_FAST_IF_AND
36485 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36486 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36487 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36488 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36489 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36490 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36491 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36492 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36493 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36494 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36495 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36496 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36497 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36498 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36499 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36500 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36501 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36502 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36503 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36504 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36505 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36506 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36507 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36508 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36509 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36510 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36511 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36512 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36513 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36514 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       198
36515 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call/nR
36516 
36517 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall__nR
36518 
36519   /* The residual arity for this instruction does not depend on fast labels. */
36520   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
36521 
36522     /* The 0th argument is a residual literal. */
36523 #if defined(JITTER_DISPATCH_NO_THREADING)
36524 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
36525     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
36526 #elif defined (JITTER_REPLICATE)
36527 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
36528 #else
36529 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
36530 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
36531 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36532 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36533 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36534 #   define JITTER_ARGF0 JITTER_ARGP0
36535 
36536 
36537 #if defined (JITTER_PROFILE_SAMPLE)
36538   JITTER_PROFILE_SAMPLE_UPDATE
36539      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36540       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36541   /* Force the compiler not move sample-profiling instrumentation
36542      beyond this point; this way the actual user code is timed.
36543      This is still not perfect, as residuals are materialised before
36544      we arrive here, but should be adequate at least for slow VM
36545      instructions. */
36546   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36547 #endif
36548 #if defined (JITTER_PROFILE_COUNT)
36549   /* Notice that, differently from the code above, this
36550      instrumentation code *can* be reordered freely: as long as a
36551      VM instruction is counted, the count increment can be placed
36552      anyehere.  Let GCC move this code and possibly achieve better
36553      throughput by exploiting instruction-level parallelism and
36554      therefore approximate more closely a non-profiled build. */
36555   JITTER_PROFILE_COUNT_UPDATE
36556      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36557       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36558 #endif
36559 
36560 /* User-specified code, instruction-beginning-c part: beginning. */
36561 
36562 
36563 /* User-specified code, instruction-beginning-c part: end */
36564 
36565 
36566     /* User code for tail-call/nR . */
36567 
36568     const jitter_uint in_arity = JITTER_ARGN0;
36569     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
36570     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
36571 
36572     if (c->kind == jitterlisp_closure_type_compiled)
36573       {
36574         /* Extract the current return address from the return stack, to be
36575            reused.  Differently from non-tail calls, don't push anything on
36576            the return stack: the callee will overwrite the top with its
36577            current value, which is what we want. */
36578         jitterlispvm_program_point current_link
36579           = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
36580 
36581         /* Branch-and-relink to the native code, whose first instruction
36582            will be a prolog. */
36583         struct jitterlisp_compiled_closure *cc = & c->compiled;
36584         JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
36585       }
36586     else
36587       {
36588         /* Unfortunately I cannot really tail-call from compiled code to
36589            interpreted code.  Instead I will call the interpreter as a C
36590            function and then return. */
36591         const struct jitterlisp_interpreted_closure *ic = & c->interpreted;
36592 
36593         /* Push an element on the main stack.  This way we can ensure that
36594            every actual is accessible thru memory in a contiguous array,
36595            even if the main stack is TOS-optimized.  Compute the address
36596            (on the main stack backing) where the actuals begin.
36597 
36598            Notice that the interpreted function we are calling is allowed
36599            to call into compiled code in its turn.  This is not a problem,
36600            as we are not moving stack pointers down until the call ends:
36601            the unused part of the main and return stacks is available to
36602            the callee. */
36603         JITTER_PUSH_UNSPECIFIED_MAINSTACK();
36604         jitterlisp_object *actuals
36605           // FIXME: add a stack operator to compute this address.
36606           = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
36607 
36608         /* Call the interpreter. */
36609         jitterlisp_object interpretation_result
36610           = jitterlisp_call_interpreted (ic, actuals, in_arity);
36611 
36612         /* Remove as many elements as the in-arity plus one (the callee) from
36613            the stack, without affecting the top.  Unless JITTER_ARGN0 is
36614            residual this whole loops compiles to one instruction when the main
36615            stack is TOS-optimized, and doesn't touch memory. */
36616         int i;
36617         for (i = 0; i < in_arity + 1; i ++)
36618           JITTER_NIP_MAINSTACK();
36619 
36620         /* Now the stack is one element higher than it was before the call,
36621            containing the unspecified element at the top.  Replace it with
36622            the result.  Again this doesn't touch memory. */
36623         JITTER_TOP_MAINSTACK() = interpretation_result;
36624 
36625         /* Return to our original caller. */
36626         jitter_uint return_address = JITTER_TOP_RETURNSTACK();
36627         JITTER_DROP_RETURNSTACK();
36628         JITTER_RETURN(return_address);
36629       }
36630 
36631     /* End of the user code for tail-call/nR . */
36632 
36633 /* User-specified code, instruction-end-c part: beginning. */
36634 
36635 
36636 /* User-specified code, instruction-end-c part: end */
36637 
36638     /* Undefine the tail-call/nR argument macros so they can't be used
36639        by mistake in the instruction body coming next. */
36640 #   undef JITTER_SLOW_REGISTER_OFFSET0
36641 #   undef JITTER_ARG0
36642 #   undef JITTER_ARGN0
36643 #   undef JITTER_ARGU0
36644 #   undef JITTER_ARGP0
36645 #   undef JITTER_ARGF0
36646 
36647 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36648 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36649 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36650 
36651   }
36652  JITTER_INSTRUCTION_EPILOG_(tail-call/nR, tail_mcall__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36653 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36654 
36655   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n0, tail_mcall_mcompiled__n0, hot)
36656   {
36657     /* This specialized instruction is not a replacement. */
36658 #   undef JITTER_BRANCH_FAST
36659 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36660 #   undef JITTER_BRANCH_FAST_IF_ZERO
36661 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36662 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36663 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36664 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36665 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36666 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36667 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36668 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36669 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36670 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36671 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36672 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36673 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36674 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36675 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36676 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36677 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36678 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36679 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36680 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36681 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36682 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36683 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36684 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36685 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36686 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36687 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36688 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36689 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36690 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36691 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36692 #   undef JITTER_BRANCH_FAST_IF_AND
36693 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36694 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36695 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36696 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36697 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36698 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36699 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36700 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36701 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36702 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36703 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36704 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36705 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36706 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36707 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36708 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36709 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36710 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36711 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36712 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36713 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36714 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36715 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36716 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36717 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36718 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36719 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36720 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36721 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36722 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       199
36723 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n0
36724 
36725 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n0
36726 
36727   /* The residual arity for this instruction does not depend on fast labels. */
36728   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36729 
36730     /* The 0th argument is a nonresidual literal. */
36731 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
36732 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36733 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36734 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36735 #   define JITTER_ARGF0 JITTER_ARGP0
36736 
36737 
36738 #if defined (JITTER_PROFILE_SAMPLE)
36739   JITTER_PROFILE_SAMPLE_UPDATE
36740      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36741       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36742   /* Force the compiler not move sample-profiling instrumentation
36743      beyond this point; this way the actual user code is timed.
36744      This is still not perfect, as residuals are materialised before
36745      we arrive here, but should be adequate at least for slow VM
36746      instructions. */
36747   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36748 #endif
36749 #if defined (JITTER_PROFILE_COUNT)
36750   /* Notice that, differently from the code above, this
36751      instrumentation code *can* be reordered freely: as long as a
36752      VM instruction is counted, the count increment can be placed
36753      anyehere.  Let GCC move this code and possibly achieve better
36754      throughput by exploiting instruction-level parallelism and
36755      therefore approximate more closely a non-profiled build. */
36756   JITTER_PROFILE_COUNT_UPDATE
36757      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36758       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36759 #endif
36760 
36761 /* User-specified code, instruction-beginning-c part: beginning. */
36762 
36763 
36764 /* User-specified code, instruction-beginning-c part: end */
36765 
36766 
36767     /* User code for tail-call-compiled/n0 . */
36768 
36769     const jitter_uint in_arity = JITTER_ARGN0;
36770     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
36771     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
36772 
36773     /* Here we can assume that * c is a compiled closure without checking. */
36774     struct jitterlisp_compiled_closure *cc = & c->compiled;
36775 
36776     /* Take the current return address from the return stack: I want to keep
36777        returning there.  Differently from the case of non-tail calls I don't
36778        push anything on the return stack: the callee prolog will overwrite
36779        the current top with a copy of itself, which is fine. */
36780     jitterlispvm_program_point current_link
36781       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
36782 
36783     /* Branch-and-relink to the native code, whose first instruction
36784        will be a prolog. */
36785     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
36786 
36787     /* End of the user code for tail-call-compiled/n0 . */
36788 
36789 /* User-specified code, instruction-end-c part: beginning. */
36790 
36791 
36792 /* User-specified code, instruction-end-c part: end */
36793 
36794     /* Undefine the tail-call-compiled/n0 argument macros so they can't be used
36795        by mistake in the instruction body coming next. */
36796 #   undef JITTER_SLOW_REGISTER_OFFSET0
36797 #   undef JITTER_ARG0
36798 #   undef JITTER_ARGN0
36799 #   undef JITTER_ARGU0
36800 #   undef JITTER_ARGP0
36801 #   undef JITTER_ARGF0
36802 
36803 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36804 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36805 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36806 
36807   }
36808  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n0, tail_mcall_mcompiled__n0, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36809 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36810 
36811   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n1, tail_mcall_mcompiled__n1, hot)
36812   {
36813     /* This specialized instruction is not a replacement. */
36814 #   undef JITTER_BRANCH_FAST
36815 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36816 #   undef JITTER_BRANCH_FAST_IF_ZERO
36817 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36818 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36819 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36820 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36821 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36822 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36823 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36824 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36825 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36826 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36827 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36828 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36829 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36830 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36831 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36832 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36833 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36834 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36835 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36836 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36837 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36838 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36839 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36840 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36841 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36842 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36843 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36844 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36845 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
36846 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36847 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
36848 #   undef JITTER_BRANCH_FAST_IF_AND
36849 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
36850 #   undef JITTER_BRANCH_FAST_IF_NOTAND
36851 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
36852 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36853 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
36854 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36855 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
36856 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36857 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
36858 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36859 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
36860 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36861 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
36862 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36863 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
36864 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36865 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
36866 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36867 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
36868 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36869 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
36870 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36871 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
36872 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36873 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
36874 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36875 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
36876 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36877 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
36878 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       200
36879 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n1
36880 
36881 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n1
36882 
36883   /* The residual arity for this instruction does not depend on fast labels. */
36884   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
36885 
36886     /* The 0th argument is a nonresidual literal. */
36887 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
36888 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
36889 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
36890 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
36891 #   define JITTER_ARGF0 JITTER_ARGP0
36892 
36893 
36894 #if defined (JITTER_PROFILE_SAMPLE)
36895   JITTER_PROFILE_SAMPLE_UPDATE
36896      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36897       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36898   /* Force the compiler not move sample-profiling instrumentation
36899      beyond this point; this way the actual user code is timed.
36900      This is still not perfect, as residuals are materialised before
36901      we arrive here, but should be adequate at least for slow VM
36902      instructions. */
36903   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
36904 #endif
36905 #if defined (JITTER_PROFILE_COUNT)
36906   /* Notice that, differently from the code above, this
36907      instrumentation code *can* be reordered freely: as long as a
36908      VM instruction is counted, the count increment can be placed
36909      anyehere.  Let GCC move this code and possibly achieve better
36910      throughput by exploiting instruction-level parallelism and
36911      therefore approximate more closely a non-profiled build. */
36912   JITTER_PROFILE_COUNT_UPDATE
36913      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
36914       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
36915 #endif
36916 
36917 /* User-specified code, instruction-beginning-c part: beginning. */
36918 
36919 
36920 /* User-specified code, instruction-beginning-c part: end */
36921 
36922 
36923     /* User code for tail-call-compiled/n1 . */
36924 
36925     const jitter_uint in_arity = JITTER_ARGN0;
36926     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
36927     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
36928 
36929     /* Here we can assume that * c is a compiled closure without checking. */
36930     struct jitterlisp_compiled_closure *cc = & c->compiled;
36931 
36932     /* Take the current return address from the return stack: I want to keep
36933        returning there.  Differently from the case of non-tail calls I don't
36934        push anything on the return stack: the callee prolog will overwrite
36935        the current top with a copy of itself, which is fine. */
36936     jitterlispvm_program_point current_link
36937       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
36938 
36939     /* Branch-and-relink to the native code, whose first instruction
36940        will be a prolog. */
36941     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
36942 
36943     /* End of the user code for tail-call-compiled/n1 . */
36944 
36945 /* User-specified code, instruction-end-c part: beginning. */
36946 
36947 
36948 /* User-specified code, instruction-end-c part: end */
36949 
36950     /* Undefine the tail-call-compiled/n1 argument macros so they can't be used
36951        by mistake in the instruction body coming next. */
36952 #   undef JITTER_SLOW_REGISTER_OFFSET0
36953 #   undef JITTER_ARG0
36954 #   undef JITTER_ARGN0
36955 #   undef JITTER_ARGU0
36956 #   undef JITTER_ARGP0
36957 #   undef JITTER_ARGF0
36958 
36959 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
36960 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
36961 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
36962 
36963   }
36964  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n1, tail_mcall_mcompiled__n1, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
36965 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
36966 
36967   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n2, tail_mcall_mcompiled__n2, hot)
36968   {
36969     /* This specialized instruction is not a replacement. */
36970 #   undef JITTER_BRANCH_FAST
36971 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
36972 #   undef JITTER_BRANCH_FAST_IF_ZERO
36973 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
36974 #   undef JITTER_BRANCH_FAST_IF_NONZERO
36975 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
36976 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
36977 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
36978 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
36979 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
36980 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
36981 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
36982 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
36983 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
36984 #   undef JITTER_BRANCH_FAST_IF_EQUAL
36985 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
36986 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
36987 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
36988 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
36989 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
36990 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36991 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
36992 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36993 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
36994 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36995 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
36996 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36997 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
36998 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
36999 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37000 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37001 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37002 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37003 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37004 #   undef JITTER_BRANCH_FAST_IF_AND
37005 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37006 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37007 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37008 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37009 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37010 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37011 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37012 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37013 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37014 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37015 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37016 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37017 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37018 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37019 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37020 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37021 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37022 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37023 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37024 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37025 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37026 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37027 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37028 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37029 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37030 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37031 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37032 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37033 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37034 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       201
37035 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n2
37036 
37037 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n2
37038 
37039   /* The residual arity for this instruction does not depend on fast labels. */
37040   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37041 
37042     /* The 0th argument is a nonresidual literal. */
37043 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
37044 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37045 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37046 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37047 #   define JITTER_ARGF0 JITTER_ARGP0
37048 
37049 
37050 #if defined (JITTER_PROFILE_SAMPLE)
37051   JITTER_PROFILE_SAMPLE_UPDATE
37052      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37053       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37054   /* Force the compiler not move sample-profiling instrumentation
37055      beyond this point; this way the actual user code is timed.
37056      This is still not perfect, as residuals are materialised before
37057      we arrive here, but should be adequate at least for slow VM
37058      instructions. */
37059   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37060 #endif
37061 #if defined (JITTER_PROFILE_COUNT)
37062   /* Notice that, differently from the code above, this
37063      instrumentation code *can* be reordered freely: as long as a
37064      VM instruction is counted, the count increment can be placed
37065      anyehere.  Let GCC move this code and possibly achieve better
37066      throughput by exploiting instruction-level parallelism and
37067      therefore approximate more closely a non-profiled build. */
37068   JITTER_PROFILE_COUNT_UPDATE
37069      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37070       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37071 #endif
37072 
37073 /* User-specified code, instruction-beginning-c part: beginning. */
37074 
37075 
37076 /* User-specified code, instruction-beginning-c part: end */
37077 
37078 
37079     /* User code for tail-call-compiled/n2 . */
37080 
37081     const jitter_uint in_arity = JITTER_ARGN0;
37082     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
37083     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
37084 
37085     /* Here we can assume that * c is a compiled closure without checking. */
37086     struct jitterlisp_compiled_closure *cc = & c->compiled;
37087 
37088     /* Take the current return address from the return stack: I want to keep
37089        returning there.  Differently from the case of non-tail calls I don't
37090        push anything on the return stack: the callee prolog will overwrite
37091        the current top with a copy of itself, which is fine. */
37092     jitterlispvm_program_point current_link
37093       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
37094 
37095     /* Branch-and-relink to the native code, whose first instruction
37096        will be a prolog. */
37097     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
37098 
37099     /* End of the user code for tail-call-compiled/n2 . */
37100 
37101 /* User-specified code, instruction-end-c part: beginning. */
37102 
37103 
37104 /* User-specified code, instruction-end-c part: end */
37105 
37106     /* Undefine the tail-call-compiled/n2 argument macros so they can't be used
37107        by mistake in the instruction body coming next. */
37108 #   undef JITTER_SLOW_REGISTER_OFFSET0
37109 #   undef JITTER_ARG0
37110 #   undef JITTER_ARGN0
37111 #   undef JITTER_ARGU0
37112 #   undef JITTER_ARGP0
37113 #   undef JITTER_ARGF0
37114 
37115 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37116 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37117 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37118 
37119   }
37120  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n2, tail_mcall_mcompiled__n2, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37121 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37122 
37123   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n3, tail_mcall_mcompiled__n3, hot)
37124   {
37125     /* This specialized instruction is not a replacement. */
37126 #   undef JITTER_BRANCH_FAST
37127 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37128 #   undef JITTER_BRANCH_FAST_IF_ZERO
37129 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37130 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37131 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37132 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37133 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37134 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37135 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37136 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37137 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37138 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37139 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37140 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37141 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37142 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37143 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37144 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37145 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37146 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37147 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37148 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37149 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37150 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37151 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37152 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37153 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37154 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37155 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37156 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37157 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37158 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37159 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37160 #   undef JITTER_BRANCH_FAST_IF_AND
37161 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37162 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37163 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37164 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37165 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37166 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37167 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37168 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37169 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37170 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37171 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37172 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37173 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37174 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37175 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37176 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37177 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37178 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37179 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37180 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37181 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37182 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37183 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37184 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37185 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37186 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37187 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37188 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37189 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37190 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       202
37191 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n3
37192 
37193 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n3
37194 
37195   /* The residual arity for this instruction does not depend on fast labels. */
37196   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37197 
37198     /* The 0th argument is a nonresidual literal. */
37199 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
37200 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37201 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37202 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37203 #   define JITTER_ARGF0 JITTER_ARGP0
37204 
37205 
37206 #if defined (JITTER_PROFILE_SAMPLE)
37207   JITTER_PROFILE_SAMPLE_UPDATE
37208      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37209       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37210   /* Force the compiler not move sample-profiling instrumentation
37211      beyond this point; this way the actual user code is timed.
37212      This is still not perfect, as residuals are materialised before
37213      we arrive here, but should be adequate at least for slow VM
37214      instructions. */
37215   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37216 #endif
37217 #if defined (JITTER_PROFILE_COUNT)
37218   /* Notice that, differently from the code above, this
37219      instrumentation code *can* be reordered freely: as long as a
37220      VM instruction is counted, the count increment can be placed
37221      anyehere.  Let GCC move this code and possibly achieve better
37222      throughput by exploiting instruction-level parallelism and
37223      therefore approximate more closely a non-profiled build. */
37224   JITTER_PROFILE_COUNT_UPDATE
37225      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37226       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37227 #endif
37228 
37229 /* User-specified code, instruction-beginning-c part: beginning. */
37230 
37231 
37232 /* User-specified code, instruction-beginning-c part: end */
37233 
37234 
37235     /* User code for tail-call-compiled/n3 . */
37236 
37237     const jitter_uint in_arity = JITTER_ARGN0;
37238     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
37239     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
37240 
37241     /* Here we can assume that * c is a compiled closure without checking. */
37242     struct jitterlisp_compiled_closure *cc = & c->compiled;
37243 
37244     /* Take the current return address from the return stack: I want to keep
37245        returning there.  Differently from the case of non-tail calls I don't
37246        push anything on the return stack: the callee prolog will overwrite
37247        the current top with a copy of itself, which is fine. */
37248     jitterlispvm_program_point current_link
37249       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
37250 
37251     /* Branch-and-relink to the native code, whose first instruction
37252        will be a prolog. */
37253     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
37254 
37255     /* End of the user code for tail-call-compiled/n3 . */
37256 
37257 /* User-specified code, instruction-end-c part: beginning. */
37258 
37259 
37260 /* User-specified code, instruction-end-c part: end */
37261 
37262     /* Undefine the tail-call-compiled/n3 argument macros so they can't be used
37263        by mistake in the instruction body coming next. */
37264 #   undef JITTER_SLOW_REGISTER_OFFSET0
37265 #   undef JITTER_ARG0
37266 #   undef JITTER_ARGN0
37267 #   undef JITTER_ARGU0
37268 #   undef JITTER_ARGP0
37269 #   undef JITTER_ARGF0
37270 
37271 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37272 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37273 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37274 
37275   }
37276  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n3, tail_mcall_mcompiled__n3, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37277 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37278 
37279   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n4, tail_mcall_mcompiled__n4, hot)
37280   {
37281     /* This specialized instruction is not a replacement. */
37282 #   undef JITTER_BRANCH_FAST
37283 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37284 #   undef JITTER_BRANCH_FAST_IF_ZERO
37285 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37286 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37287 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37288 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37289 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37290 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37291 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37292 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37293 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37294 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37295 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37296 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37297 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37298 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37299 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37300 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37301 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37302 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37303 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37304 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37305 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37306 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37307 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37308 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37309 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37310 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37311 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37312 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37313 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37314 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37315 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37316 #   undef JITTER_BRANCH_FAST_IF_AND
37317 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37318 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37319 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37320 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37321 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37322 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37323 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37324 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37325 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37326 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37327 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37328 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37329 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37330 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37331 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37332 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37333 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37334 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37335 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37336 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37337 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37338 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37339 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37340 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37341 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37342 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37343 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37344 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37345 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37346 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       203
37347 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n4
37348 
37349 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n4
37350 
37351   /* The residual arity for this instruction does not depend on fast labels. */
37352   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37353 
37354     /* The 0th argument is a nonresidual literal. */
37355 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
37356 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37357 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37358 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37359 #   define JITTER_ARGF0 JITTER_ARGP0
37360 
37361 
37362 #if defined (JITTER_PROFILE_SAMPLE)
37363   JITTER_PROFILE_SAMPLE_UPDATE
37364      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37365       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37366   /* Force the compiler not move sample-profiling instrumentation
37367      beyond this point; this way the actual user code is timed.
37368      This is still not perfect, as residuals are materialised before
37369      we arrive here, but should be adequate at least for slow VM
37370      instructions. */
37371   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37372 #endif
37373 #if defined (JITTER_PROFILE_COUNT)
37374   /* Notice that, differently from the code above, this
37375      instrumentation code *can* be reordered freely: as long as a
37376      VM instruction is counted, the count increment can be placed
37377      anyehere.  Let GCC move this code and possibly achieve better
37378      throughput by exploiting instruction-level parallelism and
37379      therefore approximate more closely a non-profiled build. */
37380   JITTER_PROFILE_COUNT_UPDATE
37381      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37382       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37383 #endif
37384 
37385 /* User-specified code, instruction-beginning-c part: beginning. */
37386 
37387 
37388 /* User-specified code, instruction-beginning-c part: end */
37389 
37390 
37391     /* User code for tail-call-compiled/n4 . */
37392 
37393     const jitter_uint in_arity = JITTER_ARGN0;
37394     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
37395     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
37396 
37397     /* Here we can assume that * c is a compiled closure without checking. */
37398     struct jitterlisp_compiled_closure *cc = & c->compiled;
37399 
37400     /* Take the current return address from the return stack: I want to keep
37401        returning there.  Differently from the case of non-tail calls I don't
37402        push anything on the return stack: the callee prolog will overwrite
37403        the current top with a copy of itself, which is fine. */
37404     jitterlispvm_program_point current_link
37405       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
37406 
37407     /* Branch-and-relink to the native code, whose first instruction
37408        will be a prolog. */
37409     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
37410 
37411     /* End of the user code for tail-call-compiled/n4 . */
37412 
37413 /* User-specified code, instruction-end-c part: beginning. */
37414 
37415 
37416 /* User-specified code, instruction-end-c part: end */
37417 
37418     /* Undefine the tail-call-compiled/n4 argument macros so they can't be used
37419        by mistake in the instruction body coming next. */
37420 #   undef JITTER_SLOW_REGISTER_OFFSET0
37421 #   undef JITTER_ARG0
37422 #   undef JITTER_ARGN0
37423 #   undef JITTER_ARGU0
37424 #   undef JITTER_ARGP0
37425 #   undef JITTER_ARGF0
37426 
37427 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37428 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37429 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37430 
37431   }
37432  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n4, tail_mcall_mcompiled__n4, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37433 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37434 
37435   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n5, tail_mcall_mcompiled__n5, hot)
37436   {
37437     /* This specialized instruction is not a replacement. */
37438 #   undef JITTER_BRANCH_FAST
37439 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37440 #   undef JITTER_BRANCH_FAST_IF_ZERO
37441 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37442 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37443 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37444 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37445 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37446 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37447 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37448 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37449 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37450 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37451 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37452 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37453 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37454 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37455 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37456 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37457 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37458 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37459 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37460 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37461 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37462 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37463 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37464 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37465 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37466 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37467 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37468 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37469 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37470 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37471 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37472 #   undef JITTER_BRANCH_FAST_IF_AND
37473 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37474 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37475 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37476 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37477 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37478 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37479 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37480 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37481 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37482 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37483 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37484 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37485 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37486 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37487 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37488 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37489 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37490 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37491 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37492 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37493 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37494 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37495 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37496 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37497 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37498 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37499 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37500 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37501 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37502 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       204
37503 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n5
37504 
37505 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n5
37506 
37507   /* The residual arity for this instruction does not depend on fast labels. */
37508   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37509 
37510     /* The 0th argument is a nonresidual literal. */
37511 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
37512 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37513 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37514 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37515 #   define JITTER_ARGF0 JITTER_ARGP0
37516 
37517 
37518 #if defined (JITTER_PROFILE_SAMPLE)
37519   JITTER_PROFILE_SAMPLE_UPDATE
37520      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37521       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37522   /* Force the compiler not move sample-profiling instrumentation
37523      beyond this point; this way the actual user code is timed.
37524      This is still not perfect, as residuals are materialised before
37525      we arrive here, but should be adequate at least for slow VM
37526      instructions. */
37527   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37528 #endif
37529 #if defined (JITTER_PROFILE_COUNT)
37530   /* Notice that, differently from the code above, this
37531      instrumentation code *can* be reordered freely: as long as a
37532      VM instruction is counted, the count increment can be placed
37533      anyehere.  Let GCC move this code and possibly achieve better
37534      throughput by exploiting instruction-level parallelism and
37535      therefore approximate more closely a non-profiled build. */
37536   JITTER_PROFILE_COUNT_UPDATE
37537      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37538       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37539 #endif
37540 
37541 /* User-specified code, instruction-beginning-c part: beginning. */
37542 
37543 
37544 /* User-specified code, instruction-beginning-c part: end */
37545 
37546 
37547     /* User code for tail-call-compiled/n5 . */
37548 
37549     const jitter_uint in_arity = JITTER_ARGN0;
37550     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
37551     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
37552 
37553     /* Here we can assume that * c is a compiled closure without checking. */
37554     struct jitterlisp_compiled_closure *cc = & c->compiled;
37555 
37556     /* Take the current return address from the return stack: I want to keep
37557        returning there.  Differently from the case of non-tail calls I don't
37558        push anything on the return stack: the callee prolog will overwrite
37559        the current top with a copy of itself, which is fine. */
37560     jitterlispvm_program_point current_link
37561       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
37562 
37563     /* Branch-and-relink to the native code, whose first instruction
37564        will be a prolog. */
37565     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
37566 
37567     /* End of the user code for tail-call-compiled/n5 . */
37568 
37569 /* User-specified code, instruction-end-c part: beginning. */
37570 
37571 
37572 /* User-specified code, instruction-end-c part: end */
37573 
37574     /* Undefine the tail-call-compiled/n5 argument macros so they can't be used
37575        by mistake in the instruction body coming next. */
37576 #   undef JITTER_SLOW_REGISTER_OFFSET0
37577 #   undef JITTER_ARG0
37578 #   undef JITTER_ARGN0
37579 #   undef JITTER_ARGU0
37580 #   undef JITTER_ARGP0
37581 #   undef JITTER_ARGF0
37582 
37583 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37584 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37585 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37586 
37587   }
37588  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n5, tail_mcall_mcompiled__n5, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37589 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37590 
37591   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n6, tail_mcall_mcompiled__n6, hot)
37592   {
37593     /* This specialized instruction is not a replacement. */
37594 #   undef JITTER_BRANCH_FAST
37595 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37596 #   undef JITTER_BRANCH_FAST_IF_ZERO
37597 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37598 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37599 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37600 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37601 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37602 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37603 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37604 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37605 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37606 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37607 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37608 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37609 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37610 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37611 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37612 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37613 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37614 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37615 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37616 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37617 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37618 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37619 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37620 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37621 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37622 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37623 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37624 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37625 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37626 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37627 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37628 #   undef JITTER_BRANCH_FAST_IF_AND
37629 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37630 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37631 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37632 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37633 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37634 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37635 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37636 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37637 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37638 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37639 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37640 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37641 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37642 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37643 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37644 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37645 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37646 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37647 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37648 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37649 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37650 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37651 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37652 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37653 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37654 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37655 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37656 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37657 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37658 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       205
37659 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n6
37660 
37661 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n6
37662 
37663   /* The residual arity for this instruction does not depend on fast labels. */
37664   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37665 
37666     /* The 0th argument is a nonresidual literal. */
37667 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
37668 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37669 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37670 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37671 #   define JITTER_ARGF0 JITTER_ARGP0
37672 
37673 
37674 #if defined (JITTER_PROFILE_SAMPLE)
37675   JITTER_PROFILE_SAMPLE_UPDATE
37676      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37677       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37678   /* Force the compiler not move sample-profiling instrumentation
37679      beyond this point; this way the actual user code is timed.
37680      This is still not perfect, as residuals are materialised before
37681      we arrive here, but should be adequate at least for slow VM
37682      instructions. */
37683   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37684 #endif
37685 #if defined (JITTER_PROFILE_COUNT)
37686   /* Notice that, differently from the code above, this
37687      instrumentation code *can* be reordered freely: as long as a
37688      VM instruction is counted, the count increment can be placed
37689      anyehere.  Let GCC move this code and possibly achieve better
37690      throughput by exploiting instruction-level parallelism and
37691      therefore approximate more closely a non-profiled build. */
37692   JITTER_PROFILE_COUNT_UPDATE
37693      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37694       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37695 #endif
37696 
37697 /* User-specified code, instruction-beginning-c part: beginning. */
37698 
37699 
37700 /* User-specified code, instruction-beginning-c part: end */
37701 
37702 
37703     /* User code for tail-call-compiled/n6 . */
37704 
37705     const jitter_uint in_arity = JITTER_ARGN0;
37706     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
37707     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
37708 
37709     /* Here we can assume that * c is a compiled closure without checking. */
37710     struct jitterlisp_compiled_closure *cc = & c->compiled;
37711 
37712     /* Take the current return address from the return stack: I want to keep
37713        returning there.  Differently from the case of non-tail calls I don't
37714        push anything on the return stack: the callee prolog will overwrite
37715        the current top with a copy of itself, which is fine. */
37716     jitterlispvm_program_point current_link
37717       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
37718 
37719     /* Branch-and-relink to the native code, whose first instruction
37720        will be a prolog. */
37721     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
37722 
37723     /* End of the user code for tail-call-compiled/n6 . */
37724 
37725 /* User-specified code, instruction-end-c part: beginning. */
37726 
37727 
37728 /* User-specified code, instruction-end-c part: end */
37729 
37730     /* Undefine the tail-call-compiled/n6 argument macros so they can't be used
37731        by mistake in the instruction body coming next. */
37732 #   undef JITTER_SLOW_REGISTER_OFFSET0
37733 #   undef JITTER_ARG0
37734 #   undef JITTER_ARGN0
37735 #   undef JITTER_ARGU0
37736 #   undef JITTER_ARGP0
37737 #   undef JITTER_ARGF0
37738 
37739 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37740 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37741 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37742 
37743   }
37744  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n6, tail_mcall_mcompiled__n6, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37745 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37746 
37747   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n7, tail_mcall_mcompiled__n7, hot)
37748   {
37749     /* This specialized instruction is not a replacement. */
37750 #   undef JITTER_BRANCH_FAST
37751 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37752 #   undef JITTER_BRANCH_FAST_IF_ZERO
37753 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37754 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37755 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37756 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37757 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37758 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37759 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37760 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37761 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37762 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37763 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37764 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37765 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37766 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37767 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37768 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37769 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37770 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37771 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37772 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37773 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37774 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37775 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37776 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37777 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37778 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37779 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37780 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37781 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37782 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37783 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37784 #   undef JITTER_BRANCH_FAST_IF_AND
37785 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37786 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37787 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37788 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37789 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37790 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37791 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37792 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37793 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37794 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37795 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37796 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37797 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37798 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37799 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37800 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37801 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37802 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37803 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37804 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37805 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37806 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37807 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37808 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37809 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37810 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37811 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37812 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37813 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37814 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       206
37815 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n7
37816 
37817 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n7
37818 
37819   /* The residual arity for this instruction does not depend on fast labels. */
37820   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37821 
37822     /* The 0th argument is a nonresidual literal. */
37823 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
37824 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37825 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37826 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37827 #   define JITTER_ARGF0 JITTER_ARGP0
37828 
37829 
37830 #if defined (JITTER_PROFILE_SAMPLE)
37831   JITTER_PROFILE_SAMPLE_UPDATE
37832      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37833       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37834   /* Force the compiler not move sample-profiling instrumentation
37835      beyond this point; this way the actual user code is timed.
37836      This is still not perfect, as residuals are materialised before
37837      we arrive here, but should be adequate at least for slow VM
37838      instructions. */
37839   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37840 #endif
37841 #if defined (JITTER_PROFILE_COUNT)
37842   /* Notice that, differently from the code above, this
37843      instrumentation code *can* be reordered freely: as long as a
37844      VM instruction is counted, the count increment can be placed
37845      anyehere.  Let GCC move this code and possibly achieve better
37846      throughput by exploiting instruction-level parallelism and
37847      therefore approximate more closely a non-profiled build. */
37848   JITTER_PROFILE_COUNT_UPDATE
37849      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37850       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37851 #endif
37852 
37853 /* User-specified code, instruction-beginning-c part: beginning. */
37854 
37855 
37856 /* User-specified code, instruction-beginning-c part: end */
37857 
37858 
37859     /* User code for tail-call-compiled/n7 . */
37860 
37861     const jitter_uint in_arity = JITTER_ARGN0;
37862     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
37863     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
37864 
37865     /* Here we can assume that * c is a compiled closure without checking. */
37866     struct jitterlisp_compiled_closure *cc = & c->compiled;
37867 
37868     /* Take the current return address from the return stack: I want to keep
37869        returning there.  Differently from the case of non-tail calls I don't
37870        push anything on the return stack: the callee prolog will overwrite
37871        the current top with a copy of itself, which is fine. */
37872     jitterlispvm_program_point current_link
37873       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
37874 
37875     /* Branch-and-relink to the native code, whose first instruction
37876        will be a prolog. */
37877     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
37878 
37879     /* End of the user code for tail-call-compiled/n7 . */
37880 
37881 /* User-specified code, instruction-end-c part: beginning. */
37882 
37883 
37884 /* User-specified code, instruction-end-c part: end */
37885 
37886     /* Undefine the tail-call-compiled/n7 argument macros so they can't be used
37887        by mistake in the instruction body coming next. */
37888 #   undef JITTER_SLOW_REGISTER_OFFSET0
37889 #   undef JITTER_ARG0
37890 #   undef JITTER_ARGN0
37891 #   undef JITTER_ARGU0
37892 #   undef JITTER_ARGP0
37893 #   undef JITTER_ARGF0
37894 
37895 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
37896 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
37897 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
37898 
37899   }
37900  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n7, tail_mcall_mcompiled__n7, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
37901 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
37902 
37903   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n8, tail_mcall_mcompiled__n8, hot)
37904   {
37905     /* This specialized instruction is not a replacement. */
37906 #   undef JITTER_BRANCH_FAST
37907 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
37908 #   undef JITTER_BRANCH_FAST_IF_ZERO
37909 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
37910 #   undef JITTER_BRANCH_FAST_IF_NONZERO
37911 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
37912 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
37913 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
37914 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
37915 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
37916 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
37917 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
37918 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
37919 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
37920 #   undef JITTER_BRANCH_FAST_IF_EQUAL
37921 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
37922 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
37923 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
37924 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
37925 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
37926 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37927 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
37928 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37929 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
37930 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37931 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
37932 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37933 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
37934 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37935 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
37936 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37937 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
37938 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37939 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
37940 #   undef JITTER_BRANCH_FAST_IF_AND
37941 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
37942 #   undef JITTER_BRANCH_FAST_IF_NOTAND
37943 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
37944 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37945 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
37946 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37947 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
37948 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37949 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
37950 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37951 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
37952 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37953 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
37954 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37955 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
37956 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37957 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
37958 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37959 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
37960 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37961 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
37962 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37963 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
37964 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37965 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
37966 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37967 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
37968 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37969 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
37970 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       207
37971 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n8
37972 
37973 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n8
37974 
37975   /* The residual arity for this instruction does not depend on fast labels. */
37976   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
37977 
37978     /* The 0th argument is a nonresidual literal. */
37979 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
37980 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
37981 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
37982 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
37983 #   define JITTER_ARGF0 JITTER_ARGP0
37984 
37985 
37986 #if defined (JITTER_PROFILE_SAMPLE)
37987   JITTER_PROFILE_SAMPLE_UPDATE
37988      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
37989       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
37990   /* Force the compiler not move sample-profiling instrumentation
37991      beyond this point; this way the actual user code is timed.
37992      This is still not perfect, as residuals are materialised before
37993      we arrive here, but should be adequate at least for slow VM
37994      instructions. */
37995   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
37996 #endif
37997 #if defined (JITTER_PROFILE_COUNT)
37998   /* Notice that, differently from the code above, this
37999      instrumentation code *can* be reordered freely: as long as a
38000      VM instruction is counted, the count increment can be placed
38001      anyehere.  Let GCC move this code and possibly achieve better
38002      throughput by exploiting instruction-level parallelism and
38003      therefore approximate more closely a non-profiled build. */
38004   JITTER_PROFILE_COUNT_UPDATE
38005      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38006       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38007 #endif
38008 
38009 /* User-specified code, instruction-beginning-c part: beginning. */
38010 
38011 
38012 /* User-specified code, instruction-beginning-c part: end */
38013 
38014 
38015     /* User code for tail-call-compiled/n8 . */
38016 
38017     const jitter_uint in_arity = JITTER_ARGN0;
38018     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
38019     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
38020 
38021     /* Here we can assume that * c is a compiled closure without checking. */
38022     struct jitterlisp_compiled_closure *cc = & c->compiled;
38023 
38024     /* Take the current return address from the return stack: I want to keep
38025        returning there.  Differently from the case of non-tail calls I don't
38026        push anything on the return stack: the callee prolog will overwrite
38027        the current top with a copy of itself, which is fine. */
38028     jitterlispvm_program_point current_link
38029       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
38030 
38031     /* Branch-and-relink to the native code, whose first instruction
38032        will be a prolog. */
38033     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
38034 
38035     /* End of the user code for tail-call-compiled/n8 . */
38036 
38037 /* User-specified code, instruction-end-c part: beginning. */
38038 
38039 
38040 /* User-specified code, instruction-end-c part: end */
38041 
38042     /* Undefine the tail-call-compiled/n8 argument macros so they can't be used
38043        by mistake in the instruction body coming next. */
38044 #   undef JITTER_SLOW_REGISTER_OFFSET0
38045 #   undef JITTER_ARG0
38046 #   undef JITTER_ARGN0
38047 #   undef JITTER_ARGU0
38048 #   undef JITTER_ARGP0
38049 #   undef JITTER_ARGF0
38050 
38051 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38052 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38053 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38054 
38055   }
38056  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n8, tail_mcall_mcompiled__n8, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38057 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38058 
38059   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n9, tail_mcall_mcompiled__n9, hot)
38060   {
38061     /* This specialized instruction is not a replacement. */
38062 #   undef JITTER_BRANCH_FAST
38063 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38064 #   undef JITTER_BRANCH_FAST_IF_ZERO
38065 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38066 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38067 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38068 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38069 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38070 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38071 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38072 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38073 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38074 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38075 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38076 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38077 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38078 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38079 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38080 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38081 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38082 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38083 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38084 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38085 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38086 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38087 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38088 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38089 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38090 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38091 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38092 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38093 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38094 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38095 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38096 #   undef JITTER_BRANCH_FAST_IF_AND
38097 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38098 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38099 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38100 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38101 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38102 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38103 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38104 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38105 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38106 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38107 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38108 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38109 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38110 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38111 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38112 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38113 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38114 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38115 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38116 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38117 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38118 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38119 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38120 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38121 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38122 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38123 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38124 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38125 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38126 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       208
38127 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n9
38128 
38129 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n9
38130 
38131   /* The residual arity for this instruction does not depend on fast labels. */
38132   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
38133 
38134     /* The 0th argument is a nonresidual literal. */
38135 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
38136 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38137 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38138 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38139 #   define JITTER_ARGF0 JITTER_ARGP0
38140 
38141 
38142 #if defined (JITTER_PROFILE_SAMPLE)
38143   JITTER_PROFILE_SAMPLE_UPDATE
38144      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38145       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38146   /* Force the compiler not move sample-profiling instrumentation
38147      beyond this point; this way the actual user code is timed.
38148      This is still not perfect, as residuals are materialised before
38149      we arrive here, but should be adequate at least for slow VM
38150      instructions. */
38151   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38152 #endif
38153 #if defined (JITTER_PROFILE_COUNT)
38154   /* Notice that, differently from the code above, this
38155      instrumentation code *can* be reordered freely: as long as a
38156      VM instruction is counted, the count increment can be placed
38157      anyehere.  Let GCC move this code and possibly achieve better
38158      throughput by exploiting instruction-level parallelism and
38159      therefore approximate more closely a non-profiled build. */
38160   JITTER_PROFILE_COUNT_UPDATE
38161      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38162       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38163 #endif
38164 
38165 /* User-specified code, instruction-beginning-c part: beginning. */
38166 
38167 
38168 /* User-specified code, instruction-beginning-c part: end */
38169 
38170 
38171     /* User code for tail-call-compiled/n9 . */
38172 
38173     const jitter_uint in_arity = JITTER_ARGN0;
38174     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
38175     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
38176 
38177     /* Here we can assume that * c is a compiled closure without checking. */
38178     struct jitterlisp_compiled_closure *cc = & c->compiled;
38179 
38180     /* Take the current return address from the return stack: I want to keep
38181        returning there.  Differently from the case of non-tail calls I don't
38182        push anything on the return stack: the callee prolog will overwrite
38183        the current top with a copy of itself, which is fine. */
38184     jitterlispvm_program_point current_link
38185       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
38186 
38187     /* Branch-and-relink to the native code, whose first instruction
38188        will be a prolog. */
38189     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
38190 
38191     /* End of the user code for tail-call-compiled/n9 . */
38192 
38193 /* User-specified code, instruction-end-c part: beginning. */
38194 
38195 
38196 /* User-specified code, instruction-end-c part: end */
38197 
38198     /* Undefine the tail-call-compiled/n9 argument macros so they can't be used
38199        by mistake in the instruction body coming next. */
38200 #   undef JITTER_SLOW_REGISTER_OFFSET0
38201 #   undef JITTER_ARG0
38202 #   undef JITTER_ARGN0
38203 #   undef JITTER_ARGU0
38204 #   undef JITTER_ARGP0
38205 #   undef JITTER_ARGF0
38206 
38207 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38208 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38209 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38210 
38211   }
38212  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n9, tail_mcall_mcompiled__n9, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38213 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38214 
38215   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/n10, tail_mcall_mcompiled__n10, hot)
38216   {
38217     /* This specialized instruction is not a replacement. */
38218 #   undef JITTER_BRANCH_FAST
38219 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38220 #   undef JITTER_BRANCH_FAST_IF_ZERO
38221 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38222 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38223 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38224 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38225 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38226 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38227 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38228 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38229 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38230 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38231 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38232 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38233 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38234 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38235 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38236 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38237 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38238 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38239 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38240 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38241 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38242 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38243 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38244 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38245 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38246 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38247 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38248 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38249 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38250 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38251 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38252 #   undef JITTER_BRANCH_FAST_IF_AND
38253 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38254 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38255 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38256 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38257 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38258 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38259 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38260 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38261 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38262 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38263 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38264 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38265 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38266 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38267 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38268 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38269 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38270 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38271 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38272 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38273 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38274 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38275 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38276 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38277 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38278 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38279 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38280 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38281 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38282 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       209
38283 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/n10
38284 
38285 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__n10
38286 
38287   /* The residual arity for this instruction does not depend on fast labels. */
38288   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
38289 
38290     /* The 0th argument is a nonresidual literal. */
38291 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
38292 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38293 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38294 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38295 #   define JITTER_ARGF0 JITTER_ARGP0
38296 
38297 
38298 #if defined (JITTER_PROFILE_SAMPLE)
38299   JITTER_PROFILE_SAMPLE_UPDATE
38300      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38301       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38302   /* Force the compiler not move sample-profiling instrumentation
38303      beyond this point; this way the actual user code is timed.
38304      This is still not perfect, as residuals are materialised before
38305      we arrive here, but should be adequate at least for slow VM
38306      instructions. */
38307   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38308 #endif
38309 #if defined (JITTER_PROFILE_COUNT)
38310   /* Notice that, differently from the code above, this
38311      instrumentation code *can* be reordered freely: as long as a
38312      VM instruction is counted, the count increment can be placed
38313      anyehere.  Let GCC move this code and possibly achieve better
38314      throughput by exploiting instruction-level parallelism and
38315      therefore approximate more closely a non-profiled build. */
38316   JITTER_PROFILE_COUNT_UPDATE
38317      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38318       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38319 #endif
38320 
38321 /* User-specified code, instruction-beginning-c part: beginning. */
38322 
38323 
38324 /* User-specified code, instruction-beginning-c part: end */
38325 
38326 
38327     /* User code for tail-call-compiled/n10 . */
38328 
38329     const jitter_uint in_arity = JITTER_ARGN0;
38330     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
38331     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
38332 
38333     /* Here we can assume that * c is a compiled closure without checking. */
38334     struct jitterlisp_compiled_closure *cc = & c->compiled;
38335 
38336     /* Take the current return address from the return stack: I want to keep
38337        returning there.  Differently from the case of non-tail calls I don't
38338        push anything on the return stack: the callee prolog will overwrite
38339        the current top with a copy of itself, which is fine. */
38340     jitterlispvm_program_point current_link
38341       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
38342 
38343     /* Branch-and-relink to the native code, whose first instruction
38344        will be a prolog. */
38345     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
38346 
38347     /* End of the user code for tail-call-compiled/n10 . */
38348 
38349 /* User-specified code, instruction-end-c part: beginning. */
38350 
38351 
38352 /* User-specified code, instruction-end-c part: end */
38353 
38354     /* Undefine the tail-call-compiled/n10 argument macros so they can't be used
38355        by mistake in the instruction body coming next. */
38356 #   undef JITTER_SLOW_REGISTER_OFFSET0
38357 #   undef JITTER_ARG0
38358 #   undef JITTER_ARGN0
38359 #   undef JITTER_ARGU0
38360 #   undef JITTER_ARGP0
38361 #   undef JITTER_ARGF0
38362 
38363 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38364 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38365 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38366 
38367   }
38368  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/n10, tail_mcall_mcompiled__n10, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38369 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38370 
38371   JITTER_INSTRUCTION_PROLOG_(tail-call-compiled/nR, tail_mcall_mcompiled__nR, cold)
38372   {
38373     /* This specialized instruction is not a replacement. */
38374 #   undef JITTER_BRANCH_FAST
38375 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38376 #   undef JITTER_BRANCH_FAST_IF_ZERO
38377 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38378 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38379 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38380 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38381 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38382 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38383 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38384 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38385 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38386 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38387 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38388 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38389 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38390 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38391 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38392 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38393 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38394 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38395 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38396 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38397 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38398 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38399 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38400 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38401 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38402 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38403 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38404 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38405 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38406 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38407 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38408 #   undef JITTER_BRANCH_FAST_IF_AND
38409 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38410 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38411 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38412 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38413 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38414 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38415 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38416 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38417 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38418 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38419 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38420 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38421 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38422 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38423 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38424 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38425 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38426 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38427 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38428 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38429 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38430 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38431 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38432 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38433 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38434 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38435 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38436 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38437 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38438 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       210
38439 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         tail-call-compiled/nR
38440 
38441 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME tail_mcall_mcompiled__nR
38442 
38443   /* The residual arity for this instruction does not depend on fast labels. */
38444   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
38445 
38446     /* The 0th argument is a residual literal. */
38447 #if defined(JITTER_DISPATCH_NO_THREADING)
38448 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38449     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38450 #elif defined (JITTER_REPLICATE)
38451 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38452 #else
38453 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38454 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38455 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38456 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38457 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38458 #   define JITTER_ARGF0 JITTER_ARGP0
38459 
38460 
38461 #if defined (JITTER_PROFILE_SAMPLE)
38462   JITTER_PROFILE_SAMPLE_UPDATE
38463      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38464       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38465   /* Force the compiler not move sample-profiling instrumentation
38466      beyond this point; this way the actual user code is timed.
38467      This is still not perfect, as residuals are materialised before
38468      we arrive here, but should be adequate at least for slow VM
38469      instructions. */
38470   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38471 #endif
38472 #if defined (JITTER_PROFILE_COUNT)
38473   /* Notice that, differently from the code above, this
38474      instrumentation code *can* be reordered freely: as long as a
38475      VM instruction is counted, the count increment can be placed
38476      anyehere.  Let GCC move this code and possibly achieve better
38477      throughput by exploiting instruction-level parallelism and
38478      therefore approximate more closely a non-profiled build. */
38479   JITTER_PROFILE_COUNT_UPDATE
38480      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38481       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38482 #endif
38483 
38484 /* User-specified code, instruction-beginning-c part: beginning. */
38485 
38486 
38487 /* User-specified code, instruction-beginning-c part: end */
38488 
38489 
38490     /* User code for tail-call-compiled/nR . */
38491 
38492     const jitter_uint in_arity = JITTER_ARGN0;
38493     jitterlisp_object callee = JITTER_AT_DEPTH_MAINSTACK(in_arity);
38494     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(callee);
38495 
38496     /* Here we can assume that * c is a compiled closure without checking. */
38497     struct jitterlisp_compiled_closure *cc = & c->compiled;
38498 
38499     /* Take the current return address from the return stack: I want to keep
38500        returning there.  Differently from the case of non-tail calls I don't
38501        push anything on the return stack: the callee prolog will overwrite
38502        the current top with a copy of itself, which is fine. */
38503     jitterlispvm_program_point current_link
38504       = (jitterlispvm_program_point) JITTER_TOP_RETURNSTACK();
38505 
38506     /* Branch-and-relink to the native code, whose first instruction
38507        will be a prolog. */
38508     JITTER_BRANCH_AND_LINK_WITH(cc->first_program_point, current_link);
38509 
38510     /* End of the user code for tail-call-compiled/nR . */
38511 
38512 /* User-specified code, instruction-end-c part: beginning. */
38513 
38514 
38515 /* User-specified code, instruction-end-c part: end */
38516 
38517     /* Undefine the tail-call-compiled/nR argument macros so they can't be used
38518        by mistake in the instruction body coming next. */
38519 #   undef JITTER_SLOW_REGISTER_OFFSET0
38520 #   undef JITTER_ARG0
38521 #   undef JITTER_ARGN0
38522 #   undef JITTER_ARGU0
38523 #   undef JITTER_ARGP0
38524 #   undef JITTER_ARGF0
38525 
38526 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38527 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38528 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38529 
38530   }
38531  JITTER_INSTRUCTION_EPILOG_(tail-call-compiled/nR, tail_mcall_mcompiled__nR, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38532 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38533 
38534   JITTER_INSTRUCTION_PROLOG_(unreachable, unreachable, cold)
38535   {
38536     /* This specialized instruction is not a replacement. */
38537 #   undef JITTER_BRANCH_FAST
38538 #   define JITTER_BRANCH_FAST _JITTER_BRANCH_FAST
38539 #   undef JITTER_BRANCH_FAST_IF_ZERO
38540 #   define JITTER_BRANCH_FAST_IF_ZERO _JITTER_BRANCH_FAST_IF_ZERO
38541 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38542 #   define JITTER_BRANCH_FAST_IF_NONZERO _JITTER_BRANCH_FAST_IF_NONZERO
38543 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38544 #   define JITTER_BRANCH_FAST_IF_POSITIVE _JITTER_BRANCH_FAST_IF_POSITIVE
38545 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38546 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE _JITTER_BRANCH_FAST_IF_NONPOSITIVE
38547 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38548 #   define JITTER_BRANCH_FAST_IF_NEGATIVE _JITTER_BRANCH_FAST_IF_NEGATIVE
38549 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38550 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE _JITTER_BRANCH_FAST_IF_NONNEGATIVE
38551 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38552 #   define JITTER_BRANCH_FAST_IF_EQUAL _JITTER_BRANCH_FAST_IF_EQUAL
38553 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38554 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL _JITTER_BRANCH_FAST_IF_NOTEQUAL
38555 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38556 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED _JITTER_BRANCH_FAST_IF_LESS_SIGNED
38557 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38558 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED _JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38559 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38560 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38561 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38562 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38563 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38564 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED _JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38565 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38566 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38567 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38568 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38569 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38570 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED _JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38571 #   undef JITTER_BRANCH_FAST_IF_AND
38572 #   define JITTER_BRANCH_FAST_IF_AND _JITTER_BRANCH_FAST_IF_AND
38573 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38574 #   define JITTER_BRANCH_FAST_IF_NOTAND _JITTER_BRANCH_FAST_IF_NOTAND
38575 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38576 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38577 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38578 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS _JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38579 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38580 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS _JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38581 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38582 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS _JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38583 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38584 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS _JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38585 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38586 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS _JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38587 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38588 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL _JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38589 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38590 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW _JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38591 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38592 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW _JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38593 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38594 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW _JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38595 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38596 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW _JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38597 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38598 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW _JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38599 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38600 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW _JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38601 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       211
38602 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         unreachable
38603 
38604 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME unreachable
38605 
38606   /* The residual arity for this instruction does not depend on fast labels. */
38607   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 0
38608 
38609 
38610 #if defined (JITTER_PROFILE_SAMPLE)
38611   JITTER_PROFILE_SAMPLE_UPDATE
38612      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38613       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38614   /* Force the compiler not move sample-profiling instrumentation
38615      beyond this point; this way the actual user code is timed.
38616      This is still not perfect, as residuals are materialised before
38617      we arrive here, but should be adequate at least for slow VM
38618      instructions. */
38619   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38620 #endif
38621 #if defined (JITTER_PROFILE_COUNT)
38622   /* Notice that, differently from the code above, this
38623      instrumentation code *can* be reordered freely: as long as a
38624      VM instruction is counted, the count increment can be placed
38625      anyehere.  Let GCC move this code and possibly achieve better
38626      throughput by exploiting instruction-level parallelism and
38627      therefore approximate more closely a non-profiled build. */
38628   JITTER_PROFILE_COUNT_UPDATE
38629      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38630       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38631 #endif
38632 
38633 /* User-specified code, instruction-beginning-c part: beginning. */
38634 
38635 
38636 /* User-specified code, instruction-beginning-c part: end */
38637 
38638 
38639     /* User code for unreachable . */
38640 
38641     /* End of the user code for unreachable . */
38642 
38643 /* User-specified code, instruction-end-c part: beginning. */
38644 
38645 
38646 /* User-specified code, instruction-end-c part: end */
38647 
38648     /* Undefine the unreachable argument macros so they can't be used
38649        by mistake in the instruction body coming next. */
38650 
38651 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38652 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38653 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38654 
38655   }
38656  JITTER_INSTRUCTION_EPILOG_(unreachable, unreachable, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38657 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38658 
38659   JITTER_INSTRUCTION_PROLOG_(*branch/fR*-no-fast-branches, _Abranch__fR_A_mno_mfast_mbranches, hot)
38660   {
38661     /* This specialized instruction is a replacement. */
38662 #   undef JITTER_BRANCH_FAST
38663 #   define JITTER_BRANCH_FAST JITTER_BRANCH
38664 #   undef JITTER_BRANCH_FAST_IF_ZERO
38665 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
38666 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38667 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
38668 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38669 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
38670 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38671 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
38672 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38673 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
38674 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38675 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
38676 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38677 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
38678 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38679 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
38680 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38681 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
38682 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38683 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
38684 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38685 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
38686 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38687 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
38688 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38689 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
38690 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38691 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
38692 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38693 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
38694 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38695 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
38696 #   undef JITTER_BRANCH_FAST_IF_AND
38697 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
38698 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38699 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
38700 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38701 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
38702 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38703 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
38704 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38705 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
38706 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38707 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
38708 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38709 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
38710 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38711 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
38712 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38713 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
38714 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38715 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
38716 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38717 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
38718 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38719 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
38720 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38721 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
38722 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38723 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
38724 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38725 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
38726     /* This specialized instruction is non-relocatable.
38727        Its 0-th argument, a literal, is the return address where to jump
38728        at the end, back to relocated code. */
38729 
38730 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       212
38731 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *branch/fR*-no-fast-branches
38732 
38733 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abranch__fR_A_mno_mfast_mbranches
38734 
38735   /* The residual arity for this instruction does not depend on fast labels. */
38736   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
38737 
38738   /* Define argument-access macros for *branch/fR*-no-fast-branches . */
38739 #ifdef JITTER_HAVE_PATCH_IN
38740   /* Define argument-access macros assuming that fast branches are enabled. */
38741     /* The 0th argument is a residual label. */
38742 #if defined(JITTER_DISPATCH_NO_THREADING)
38743 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38744     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38745 #elif defined (JITTER_REPLICATE)
38746 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38747 #else
38748 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38749 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38750 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38751 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38752 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38753 #   define JITTER_ARGF0 JITTER_ARGP0
38754 
38755 #else
38756   /* Define argument-access macros assuming that fast branches are disabled. */
38757     /* The 0th argument is a residual label. */
38758 #if defined(JITTER_DISPATCH_NO_THREADING)
38759 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38760     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38761 #elif defined (JITTER_REPLICATE)
38762 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38763 #else
38764 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38765 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38766 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38767 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38768 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38769 #   define JITTER_ARGF0 JITTER_ARGP0
38770 
38771 # endif // #ifdef JITTER_HAVE_PATCH_IN
38772 
38773 #ifdef JITTER_REPLICATE
38774     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
38775        it on the stack rather than in read-only memory.  I had to do this to prevent
38776        a GCC 8 snapshot on SH from being too clever. */
38777     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
38778     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
38779        in memory, as a 16-bit constant; and since it reads it with a PC-relative
38780        load the relocated part crashes.
38781                  mov.w     .L1667,r0
38782                  mov.l     @(r0,r15),r1
38783                  jmp       @r1
38784        r15 is the stack pointer.  The constant at .L1667 is
38785           .L1667:
38786                  .short    232
38787        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
38788        can't work as an immediate.  Shall I keep these code pointers as a single array?
38789        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
38790        but the problem will be the same. */
38791     /* Jump to non-relocatable code. */
38792     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
38793 
38794     /* Here the residual arity is given as zero: it's too late to
38795        skip residuals, since we've already jumped and this code is
38796        unreachable.  The instruction pointer, if any, is advanced
38797        in the non-relocatable code. */
38798     JITTER_INSTRUCTION_EPILOG_(*branch/fR*-no-fast-branches, _Abranch__fR_A_mno_mfast_mbranches, 0)
38799 
38800     /* Relocated code will jump to this label in non-relocated code. */
38801   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
38802     JITTER_COMMENT_IN_ASM_("*branch/fR*-no-fast-branches non-relocatable code");
38803 #endif // #ifdef JITTER_REPLICATE
38804 #if defined (JITTER_PROFILE_SAMPLE)
38805   JITTER_PROFILE_SAMPLE_UPDATE
38806      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38807       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38808   /* Force the compiler not move sample-profiling instrumentation
38809      beyond this point; this way the actual user code is timed.
38810      This is still not perfect, as residuals are materialised before
38811      we arrive here, but should be adequate at least for slow VM
38812      instructions. */
38813   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
38814 #endif
38815 #if defined (JITTER_PROFILE_COUNT)
38816   /* Notice that, differently from the code above, this
38817      instrumentation code *can* be reordered freely: as long as a
38818      VM instruction is counted, the count increment can be placed
38819      anyehere.  Let GCC move this code and possibly achieve better
38820      throughput by exploiting instruction-level parallelism and
38821      therefore approximate more closely a non-profiled build. */
38822   JITTER_PROFILE_COUNT_UPDATE
38823      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
38824       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
38825 #endif
38826 
38827 /* User-specified code, instruction-beginning-c part: beginning. */
38828 
38829 
38830 /* User-specified code, instruction-beginning-c part: end */
38831 
38832 
38833     /* User code for *branch/fR*-no-fast-branches . */
38834 
38835     JITTER_BRANCH_FAST(JITTER_ARGF0);
38836 
38837     /* End of the user code for *branch/fR*-no-fast-branches . */
38838 
38839 /* User-specified code, instruction-end-c part: beginning. */
38840 
38841 
38842 /* User-specified code, instruction-end-c part: end */
38843 
38844 #ifdef JITTER_REPLICATE
38845     /* Advance the instruction pointer, if any, to skip residuals;
38846        then jump back to replicated code. */
38847     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
38848     JITTER_SKIP_RESIDUALS_;
38849     goto * _jitter_back_to_replicated_code_pointer;
38850 #endif // #ifdef JITTER_REPLICATE
38851 
38852     /* Undefine the *branch/fR*-no-fast-branches argument macros so they can't be used
38853        by mistake in the instruction body coming next. */
38854 #   undef JITTER_SLOW_REGISTER_OFFSET0
38855 #   undef JITTER_ARG0
38856 #   undef JITTER_ARGN0
38857 #   undef JITTER_ARGU0
38858 #   undef JITTER_ARGP0
38859 #   undef JITTER_ARGF0
38860 
38861 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
38862 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
38863 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
38864 
38865   }
38866 #ifndef JITTER_REPLICATE
38867  JITTER_INSTRUCTION_EPILOG_(*branch/fR*-no-fast-branches, _Abranch__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
38868 #endif // #ifndef JITTER_REPLICATE
38869 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
38870 
38871   JITTER_INSTRUCTION_PROLOG_(*branch-if-false/fR*-no-fast-branches, _Abranch_mif_mfalse__fR_A_mno_mfast_mbranches, hot)
38872   {
38873     /* This specialized instruction is a replacement. */
38874 #   undef JITTER_BRANCH_FAST
38875 #   define JITTER_BRANCH_FAST JITTER_BRANCH
38876 #   undef JITTER_BRANCH_FAST_IF_ZERO
38877 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
38878 #   undef JITTER_BRANCH_FAST_IF_NONZERO
38879 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
38880 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
38881 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
38882 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
38883 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
38884 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
38885 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
38886 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
38887 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
38888 #   undef JITTER_BRANCH_FAST_IF_EQUAL
38889 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
38890 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
38891 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
38892 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
38893 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
38894 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
38895 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
38896 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
38897 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
38898 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
38899 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
38900 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
38901 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
38902 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
38903 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
38904 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
38905 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
38906 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
38907 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
38908 #   undef JITTER_BRANCH_FAST_IF_AND
38909 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
38910 #   undef JITTER_BRANCH_FAST_IF_NOTAND
38911 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
38912 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
38913 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
38914 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
38915 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
38916 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
38917 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
38918 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
38919 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
38920 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
38921 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
38922 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
38923 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
38924 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
38925 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
38926 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
38927 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
38928 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
38929 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
38930 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
38931 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
38932 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
38933 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
38934 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
38935 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
38936 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
38937 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
38938     /* This specialized instruction is non-relocatable.
38939        Its 0-th argument, a literal, is the return address where to jump
38940        at the end, back to relocated code. */
38941 
38942 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       213
38943 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *branch-if-false/fR*-no-fast-branches
38944 
38945 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abranch_mif_mfalse__fR_A_mno_mfast_mbranches
38946 
38947   /* The residual arity for this instruction does not depend on fast labels. */
38948   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
38949 
38950   /* Define argument-access macros for *branch-if-false/fR*-no-fast-branches . */
38951 #ifdef JITTER_HAVE_PATCH_IN
38952   /* Define argument-access macros assuming that fast branches are enabled. */
38953     /* The 0th argument is a residual label. */
38954 #if defined(JITTER_DISPATCH_NO_THREADING)
38955 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38956     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38957 #elif defined (JITTER_REPLICATE)
38958 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38959 #else
38960 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38961 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38962 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38963 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38964 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38965 #   define JITTER_ARGF0 JITTER_ARGP0
38966 
38967 #else
38968   /* Define argument-access macros assuming that fast branches are disabled. */
38969     /* The 0th argument is a residual label. */
38970 #if defined(JITTER_DISPATCH_NO_THREADING)
38971 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
38972     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
38973 #elif defined (JITTER_REPLICATE)
38974 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
38975 #else
38976 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
38977 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
38978 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
38979 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
38980 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
38981 #   define JITTER_ARGF0 JITTER_ARGP0
38982 
38983 # endif // #ifdef JITTER_HAVE_PATCH_IN
38984 
38985 #ifdef JITTER_REPLICATE
38986     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
38987        it on the stack rather than in read-only memory.  I had to do this to prevent
38988        a GCC 8 snapshot on SH from being too clever. */
38989     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
38990     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
38991        in memory, as a 16-bit constant; and since it reads it with a PC-relative
38992        load the relocated part crashes.
38993                  mov.w     .L1667,r0
38994                  mov.l     @(r0,r15),r1
38995                  jmp       @r1
38996        r15 is the stack pointer.  The constant at .L1667 is
38997           .L1667:
38998                  .short    232
38999        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
39000        can't work as an immediate.  Shall I keep these code pointers as a single array?
39001        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
39002        but the problem will be the same. */
39003     /* Jump to non-relocatable code. */
39004     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39005 
39006     /* Here the residual arity is given as zero: it's too late to
39007        skip residuals, since we've already jumped and this code is
39008        unreachable.  The instruction pointer, if any, is advanced
39009        in the non-relocatable code. */
39010     JITTER_INSTRUCTION_EPILOG_(*branch-if-false/fR*-no-fast-branches, _Abranch_mif_mfalse__fR_A_mno_mfast_mbranches, 0)
39011 
39012     /* Relocated code will jump to this label in non-relocated code. */
39013   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
39014     JITTER_COMMENT_IN_ASM_("*branch-if-false/fR*-no-fast-branches non-relocatable code");
39015 #endif // #ifdef JITTER_REPLICATE
39016 #if defined (JITTER_PROFILE_SAMPLE)
39017   JITTER_PROFILE_SAMPLE_UPDATE
39018      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39019       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39020   /* Force the compiler not move sample-profiling instrumentation
39021      beyond this point; this way the actual user code is timed.
39022      This is still not perfect, as residuals are materialised before
39023      we arrive here, but should be adequate at least for slow VM
39024      instructions. */
39025   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39026 #endif
39027 #if defined (JITTER_PROFILE_COUNT)
39028   /* Notice that, differently from the code above, this
39029      instrumentation code *can* be reordered freely: as long as a
39030      VM instruction is counted, the count increment can be placed
39031      anyehere.  Let GCC move this code and possibly achieve better
39032      throughput by exploiting instruction-level parallelism and
39033      therefore approximate more closely a non-profiled build. */
39034   JITTER_PROFILE_COUNT_UPDATE
39035      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39036       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39037 #endif
39038 
39039 /* User-specified code, instruction-beginning-c part: beginning. */
39040 
39041 
39042 /* User-specified code, instruction-beginning-c part: end */
39043 
39044 
39045     /* User code for *branch-if-false/fR*-no-fast-branches . */
39046 
39047     jitterlisp_object top = JITTER_TOP_MAINSTACK();
39048     JITTER_DROP_MAINSTACK();
39049     JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
39050 
39051     /* End of the user code for *branch-if-false/fR*-no-fast-branches . */
39052 
39053 /* User-specified code, instruction-end-c part: beginning. */
39054 
39055 
39056 /* User-specified code, instruction-end-c part: end */
39057 
39058 #ifdef JITTER_REPLICATE
39059     /* Advance the instruction pointer, if any, to skip residuals;
39060        then jump back to replicated code. */
39061     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
39062     JITTER_SKIP_RESIDUALS_;
39063     goto * _jitter_back_to_replicated_code_pointer;
39064 #endif // #ifdef JITTER_REPLICATE
39065 
39066     /* Undefine the *branch-if-false/fR*-no-fast-branches argument macros so they can't be used
39067        by mistake in the instruction body coming next. */
39068 #   undef JITTER_SLOW_REGISTER_OFFSET0
39069 #   undef JITTER_ARG0
39070 #   undef JITTER_ARGN0
39071 #   undef JITTER_ARGU0
39072 #   undef JITTER_ARGP0
39073 #   undef JITTER_ARGF0
39074 
39075 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39076 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39077 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39078 
39079   }
39080 #ifndef JITTER_REPLICATE
39081  JITTER_INSTRUCTION_EPILOG_(*branch-if-false/fR*-no-fast-branches, _Abranch_mif_mfalse__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39082 #endif // #ifndef JITTER_REPLICATE
39083 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39084 
39085   JITTER_INSTRUCTION_PROLOG_(*branch-if-not-less/fR/fR*-no-fast-branches, _Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches, hot)
39086   {
39087     /* This specialized instruction is a replacement. */
39088 #   undef JITTER_BRANCH_FAST
39089 #   define JITTER_BRANCH_FAST JITTER_BRANCH
39090 #   undef JITTER_BRANCH_FAST_IF_ZERO
39091 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
39092 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39093 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
39094 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39095 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
39096 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39097 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
39098 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39099 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
39100 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39101 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
39102 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39103 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
39104 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39105 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
39106 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39107 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
39108 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39109 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
39110 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39111 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
39112 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39113 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
39114 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39115 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
39116 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39117 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
39118 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39119 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
39120 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39121 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
39122 #   undef JITTER_BRANCH_FAST_IF_AND
39123 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
39124 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39125 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
39126 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39127 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
39128 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39129 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
39130 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39131 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
39132 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39133 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
39134 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39135 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
39136 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39137 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
39138 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39139 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
39140 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39141 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
39142 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39143 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
39144 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39145 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
39146 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39147 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
39148 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39149 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
39150 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39151 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
39152     /* This specialized instruction is non-relocatable.
39153        Its 1-th argument, a literal, is the return address where to jump
39154        at the end, back to relocated code. */
39155 
39156 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       214
39157 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *branch-if-not-less/fR/fR*-no-fast-branches
39158 
39159 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches
39160 
39161   /* The residual arity for this instruction does not depend on fast labels. */
39162   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
39163 
39164   /* Define argument-access macros for *branch-if-not-less/fR/fR*-no-fast-branches . */
39165 #ifdef JITTER_HAVE_PATCH_IN
39166   /* Define argument-access macros assuming that fast branches are enabled. */
39167     /* The 0th argument is a residual label. */
39168 #if defined(JITTER_DISPATCH_NO_THREADING)
39169 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
39170     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
39171 #elif defined (JITTER_REPLICATE)
39172 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
39173 #else
39174 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
39175 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39176 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39177 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39178 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39179 #   define JITTER_ARGF0 JITTER_ARGP0
39180 
39181     /* The 1th argument is a residual label. */
39182 #if defined(JITTER_DISPATCH_NO_THREADING)
39183 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
39184     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
39185 #elif defined (JITTER_REPLICATE)
39186 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
39187 #else
39188 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
39189 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39190 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
39191 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
39192 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
39193 #   define JITTER_ARGF1 JITTER_ARGP1
39194 
39195 #else
39196   /* Define argument-access macros assuming that fast branches are disabled. */
39197     /* The 0th argument is a residual label. */
39198 #if defined(JITTER_DISPATCH_NO_THREADING)
39199 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
39200     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
39201 #elif defined (JITTER_REPLICATE)
39202 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
39203 #else
39204 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
39205 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39206 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39207 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39208 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39209 #   define JITTER_ARGF0 JITTER_ARGP0
39210 
39211     /* The 1th argument is a residual label. */
39212 #if defined(JITTER_DISPATCH_NO_THREADING)
39213 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
39214     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
39215 #elif defined (JITTER_REPLICATE)
39216 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
39217 #else
39218 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
39219 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39220 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
39221 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
39222 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
39223 #   define JITTER_ARGF1 JITTER_ARGP1
39224 
39225 # endif // #ifdef JITTER_HAVE_PATCH_IN
39226 
39227 #ifdef JITTER_REPLICATE
39228     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
39229        it on the stack rather than in read-only memory.  I had to do this to prevent
39230        a GCC 8 snapshot on SH from being too clever. */
39231     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39232     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
39233        in memory, as a 16-bit constant; and since it reads it with a PC-relative
39234        load the relocated part crashes.
39235                  mov.w     .L1667,r0
39236                  mov.l     @(r0,r15),r1
39237                  jmp       @r1
39238        r15 is the stack pointer.  The constant at .L1667 is
39239           .L1667:
39240                  .short    232
39241        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
39242        can't work as an immediate.  Shall I keep these code pointers as a single array?
39243        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
39244        but the problem will be the same. */
39245     /* Jump to non-relocatable code. */
39246     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39247 
39248     /* Here the residual arity is given as zero: it's too late to
39249        skip residuals, since we've already jumped and this code is
39250        unreachable.  The instruction pointer, if any, is advanced
39251        in the non-relocatable code. */
39252     JITTER_INSTRUCTION_EPILOG_(*branch-if-not-less/fR/fR*-no-fast-branches, _Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches, 0)
39253 
39254     /* Relocated code will jump to this label in non-relocated code. */
39255   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
39256     JITTER_COMMENT_IN_ASM_("*branch-if-not-less/fR/fR*-no-fast-branches non-relocatable code");
39257 #endif // #ifdef JITTER_REPLICATE
39258 #if defined (JITTER_PROFILE_SAMPLE)
39259   JITTER_PROFILE_SAMPLE_UPDATE
39260      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39261       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39262   /* Force the compiler not move sample-profiling instrumentation
39263      beyond this point; this way the actual user code is timed.
39264      This is still not perfect, as residuals are materialised before
39265      we arrive here, but should be adequate at least for slow VM
39266      instructions. */
39267   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39268 #endif
39269 #if defined (JITTER_PROFILE_COUNT)
39270   /* Notice that, differently from the code above, this
39271      instrumentation code *can* be reordered freely: as long as a
39272      VM instruction is counted, the count increment can be placed
39273      anyehere.  Let GCC move this code and possibly achieve better
39274      throughput by exploiting instruction-level parallelism and
39275      therefore approximate more closely a non-profiled build. */
39276   JITTER_PROFILE_COUNT_UPDATE
39277      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39278       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39279 #endif
39280 
39281 /* User-specified code, instruction-beginning-c part: beginning. */
39282 
39283 
39284 /* User-specified code, instruction-beginning-c part: end */
39285 
39286 
39287     /* User code for *branch-if-not-less/fR/fR*-no-fast-branches . */
39288 
39289     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF1);
39290     jitterlisp_object undertop = JITTER_UNDER_TOP_MAINSTACK();
39291     jitterlisp_object top = JITTER_TOP_MAINSTACK();
39292     JITTER_NIP_MAINSTACK();
39293     JITTER_DROP_MAINSTACK();
39294     JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED(undertop, top, JITTER_ARGF0);
39295 
39296     /* End of the user code for *branch-if-not-less/fR/fR*-no-fast-branches . */
39297 
39298 /* User-specified code, instruction-end-c part: beginning. */
39299 
39300 
39301 /* User-specified code, instruction-end-c part: end */
39302 
39303 #ifdef JITTER_REPLICATE
39304     /* Advance the instruction pointer, if any, to skip residuals;
39305        then jump back to replicated code. */
39306     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
39307     JITTER_SKIP_RESIDUALS_;
39308     goto * _jitter_back_to_replicated_code_pointer;
39309 #endif // #ifdef JITTER_REPLICATE
39310 
39311     /* Undefine the *branch-if-not-less/fR/fR*-no-fast-branches argument macros so they can't be used
39312        by mistake in the instruction body coming next. */
39313 #   undef JITTER_SLOW_REGISTER_OFFSET0
39314 #   undef JITTER_ARG0
39315 #   undef JITTER_ARGN0
39316 #   undef JITTER_ARGU0
39317 #   undef JITTER_ARGP0
39318 #   undef JITTER_ARGF0
39319 #   undef JITTER_SLOW_REGISTER_OFFSET1
39320 #   undef JITTER_ARG1
39321 #   undef JITTER_ARGN1
39322 #   undef JITTER_ARGU1
39323 #   undef JITTER_ARGP1
39324 #   undef JITTER_ARGF1
39325 
39326 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39327 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39328 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39329 
39330   }
39331 #ifndef JITTER_REPLICATE
39332  JITTER_INSTRUCTION_EPILOG_(*branch-if-not-less/fR/fR*-no-fast-branches, _Abranch_mif_mnot_mless__fR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39333 #endif // #ifndef JITTER_REPLICATE
39334 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39335 
39336   JITTER_INSTRUCTION_PROLOG_(*branch-if-not-null/fR*-no-fast-branches, _Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches, hot)
39337   {
39338     /* This specialized instruction is a replacement. */
39339 #   undef JITTER_BRANCH_FAST
39340 #   define JITTER_BRANCH_FAST JITTER_BRANCH
39341 #   undef JITTER_BRANCH_FAST_IF_ZERO
39342 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
39343 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39344 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
39345 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39346 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
39347 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39348 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
39349 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39350 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
39351 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39352 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
39353 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39354 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
39355 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39356 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
39357 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39358 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
39359 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39360 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
39361 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39362 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
39363 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39364 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
39365 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39366 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
39367 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39368 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
39369 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39370 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
39371 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39372 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
39373 #   undef JITTER_BRANCH_FAST_IF_AND
39374 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
39375 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39376 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
39377 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39378 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
39379 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39380 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
39381 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39382 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
39383 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39384 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
39385 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39386 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
39387 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39388 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
39389 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39390 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
39391 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39392 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
39393 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39394 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
39395 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39396 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
39397 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39398 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
39399 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39400 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
39401 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39402 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
39403     /* This specialized instruction is non-relocatable.
39404        Its 0-th argument, a literal, is the return address where to jump
39405        at the end, back to relocated code. */
39406 
39407 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       215
39408 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *branch-if-not-null/fR*-no-fast-branches
39409 
39410 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches
39411 
39412   /* The residual arity for this instruction does not depend on fast labels. */
39413   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
39414 
39415   /* Define argument-access macros for *branch-if-not-null/fR*-no-fast-branches . */
39416 #ifdef JITTER_HAVE_PATCH_IN
39417   /* Define argument-access macros assuming that fast branches are enabled. */
39418     /* The 0th argument is a residual label. */
39419 #if defined(JITTER_DISPATCH_NO_THREADING)
39420 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
39421     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
39422 #elif defined (JITTER_REPLICATE)
39423 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
39424 #else
39425 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
39426 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39427 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39428 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39429 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39430 #   define JITTER_ARGF0 JITTER_ARGP0
39431 
39432 #else
39433   /* Define argument-access macros assuming that fast branches are disabled. */
39434     /* The 0th argument is a residual label. */
39435 #if defined(JITTER_DISPATCH_NO_THREADING)
39436 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
39437     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
39438 #elif defined (JITTER_REPLICATE)
39439 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
39440 #else
39441 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
39442 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39443 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39444 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39445 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39446 #   define JITTER_ARGF0 JITTER_ARGP0
39447 
39448 # endif // #ifdef JITTER_HAVE_PATCH_IN
39449 
39450 #ifdef JITTER_REPLICATE
39451     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
39452        it on the stack rather than in read-only memory.  I had to do this to prevent
39453        a GCC 8 snapshot on SH from being too clever. */
39454     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39455     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
39456        in memory, as a 16-bit constant; and since it reads it with a PC-relative
39457        load the relocated part crashes.
39458                  mov.w     .L1667,r0
39459                  mov.l     @(r0,r15),r1
39460                  jmp       @r1
39461        r15 is the stack pointer.  The constant at .L1667 is
39462           .L1667:
39463                  .short    232
39464        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
39465        can't work as an immediate.  Shall I keep these code pointers as a single array?
39466        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
39467        but the problem will be the same. */
39468     /* Jump to non-relocatable code. */
39469     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39470 
39471     /* Here the residual arity is given as zero: it's too late to
39472        skip residuals, since we've already jumped and this code is
39473        unreachable.  The instruction pointer, if any, is advanced
39474        in the non-relocatable code. */
39475     JITTER_INSTRUCTION_EPILOG_(*branch-if-not-null/fR*-no-fast-branches, _Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches, 0)
39476 
39477     /* Relocated code will jump to this label in non-relocated code. */
39478   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
39479     JITTER_COMMENT_IN_ASM_("*branch-if-not-null/fR*-no-fast-branches non-relocatable code");
39480 #endif // #ifdef JITTER_REPLICATE
39481 #if defined (JITTER_PROFILE_SAMPLE)
39482   JITTER_PROFILE_SAMPLE_UPDATE
39483      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39484       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39485   /* Force the compiler not move sample-profiling instrumentation
39486      beyond this point; this way the actual user code is timed.
39487      This is still not perfect, as residuals are materialised before
39488      we arrive here, but should be adequate at least for slow VM
39489      instructions. */
39490   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39491 #endif
39492 #if defined (JITTER_PROFILE_COUNT)
39493   /* Notice that, differently from the code above, this
39494      instrumentation code *can* be reordered freely: as long as a
39495      VM instruction is counted, the count increment can be placed
39496      anyehere.  Let GCC move this code and possibly achieve better
39497      throughput by exploiting instruction-level parallelism and
39498      therefore approximate more closely a non-profiled build. */
39499   JITTER_PROFILE_COUNT_UPDATE
39500      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39501       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39502 #endif
39503 
39504 /* User-specified code, instruction-beginning-c part: beginning. */
39505 
39506 
39507 /* User-specified code, instruction-beginning-c part: end */
39508 
39509 
39510     /* User code for *branch-if-not-null/fR*-no-fast-branches . */
39511 
39512     jitterlisp_object top = JITTER_TOP_MAINSTACK();
39513     JITTER_DROP_MAINSTACK();
39514     JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
39515 
39516     /* End of the user code for *branch-if-not-null/fR*-no-fast-branches . */
39517 
39518 /* User-specified code, instruction-end-c part: beginning. */
39519 
39520 
39521 /* User-specified code, instruction-end-c part: end */
39522 
39523 #ifdef JITTER_REPLICATE
39524     /* Advance the instruction pointer, if any, to skip residuals;
39525        then jump back to replicated code. */
39526     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
39527     JITTER_SKIP_RESIDUALS_;
39528     goto * _jitter_back_to_replicated_code_pointer;
39529 #endif // #ifdef JITTER_REPLICATE
39530 
39531     /* Undefine the *branch-if-not-null/fR*-no-fast-branches argument macros so they can't be used
39532        by mistake in the instruction body coming next. */
39533 #   undef JITTER_SLOW_REGISTER_OFFSET0
39534 #   undef JITTER_ARG0
39535 #   undef JITTER_ARGN0
39536 #   undef JITTER_ARGU0
39537 #   undef JITTER_ARGP0
39538 #   undef JITTER_ARGF0
39539 
39540 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39541 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39542 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39543 
39544   }
39545 #ifndef JITTER_REPLICATE
39546  JITTER_INSTRUCTION_EPILOG_(*branch-if-not-null/fR*-no-fast-branches, _Abranch_mif_mnot_mnull__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39547 #endif // #ifndef JITTER_REPLICATE
39548 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39549 
39550   JITTER_INSTRUCTION_PROLOG_(*branch-if-null/fR*-no-fast-branches, _Abranch_mif_mnull__fR_A_mno_mfast_mbranches, hot)
39551   {
39552     /* This specialized instruction is a replacement. */
39553 #   undef JITTER_BRANCH_FAST
39554 #   define JITTER_BRANCH_FAST JITTER_BRANCH
39555 #   undef JITTER_BRANCH_FAST_IF_ZERO
39556 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
39557 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39558 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
39559 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39560 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
39561 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39562 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
39563 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39564 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
39565 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39566 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
39567 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39568 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
39569 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39570 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
39571 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39572 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
39573 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39574 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
39575 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39576 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
39577 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39578 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
39579 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39580 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
39581 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39582 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
39583 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39584 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
39585 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39586 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
39587 #   undef JITTER_BRANCH_FAST_IF_AND
39588 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
39589 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39590 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
39591 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39592 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
39593 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39594 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
39595 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39596 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
39597 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39598 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
39599 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39600 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
39601 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39602 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
39603 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39604 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
39605 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39606 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
39607 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39608 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
39609 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39610 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
39611 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39612 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
39613 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39614 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
39615 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39616 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
39617     /* This specialized instruction is non-relocatable.
39618        Its 0-th argument, a literal, is the return address where to jump
39619        at the end, back to relocated code. */
39620 
39621 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       216
39622 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *branch-if-null/fR*-no-fast-branches
39623 
39624 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abranch_mif_mnull__fR_A_mno_mfast_mbranches
39625 
39626   /* The residual arity for this instruction does not depend on fast labels. */
39627   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
39628 
39629   /* Define argument-access macros for *branch-if-null/fR*-no-fast-branches . */
39630 #ifdef JITTER_HAVE_PATCH_IN
39631   /* Define argument-access macros assuming that fast branches are enabled. */
39632     /* The 0th argument is a residual label. */
39633 #if defined(JITTER_DISPATCH_NO_THREADING)
39634 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
39635     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
39636 #elif defined (JITTER_REPLICATE)
39637 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
39638 #else
39639 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
39640 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39641 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39642 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39643 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39644 #   define JITTER_ARGF0 JITTER_ARGP0
39645 
39646 #else
39647   /* Define argument-access macros assuming that fast branches are disabled. */
39648     /* The 0th argument is a residual label. */
39649 #if defined(JITTER_DISPATCH_NO_THREADING)
39650 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
39651     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
39652 #elif defined (JITTER_REPLICATE)
39653 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
39654 #else
39655 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
39656 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39657 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39658 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39659 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39660 #   define JITTER_ARGF0 JITTER_ARGP0
39661 
39662 # endif // #ifdef JITTER_HAVE_PATCH_IN
39663 
39664 #ifdef JITTER_REPLICATE
39665     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
39666        it on the stack rather than in read-only memory.  I had to do this to prevent
39667        a GCC 8 snapshot on SH from being too clever. */
39668     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39669     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
39670        in memory, as a 16-bit constant; and since it reads it with a PC-relative
39671        load the relocated part crashes.
39672                  mov.w     .L1667,r0
39673                  mov.l     @(r0,r15),r1
39674                  jmp       @r1
39675        r15 is the stack pointer.  The constant at .L1667 is
39676           .L1667:
39677                  .short    232
39678        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
39679        can't work as an immediate.  Shall I keep these code pointers as a single array?
39680        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
39681        but the problem will be the same. */
39682     /* Jump to non-relocatable code. */
39683     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39684 
39685     /* Here the residual arity is given as zero: it's too late to
39686        skip residuals, since we've already jumped and this code is
39687        unreachable.  The instruction pointer, if any, is advanced
39688        in the non-relocatable code. */
39689     JITTER_INSTRUCTION_EPILOG_(*branch-if-null/fR*-no-fast-branches, _Abranch_mif_mnull__fR_A_mno_mfast_mbranches, 0)
39690 
39691     /* Relocated code will jump to this label in non-relocated code. */
39692   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
39693     JITTER_COMMENT_IN_ASM_("*branch-if-null/fR*-no-fast-branches non-relocatable code");
39694 #endif // #ifdef JITTER_REPLICATE
39695 #if defined (JITTER_PROFILE_SAMPLE)
39696   JITTER_PROFILE_SAMPLE_UPDATE
39697      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39698       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39699   /* Force the compiler not move sample-profiling instrumentation
39700      beyond this point; this way the actual user code is timed.
39701      This is still not perfect, as residuals are materialised before
39702      we arrive here, but should be adequate at least for slow VM
39703      instructions. */
39704   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39705 #endif
39706 #if defined (JITTER_PROFILE_COUNT)
39707   /* Notice that, differently from the code above, this
39708      instrumentation code *can* be reordered freely: as long as a
39709      VM instruction is counted, the count increment can be placed
39710      anyehere.  Let GCC move this code and possibly achieve better
39711      throughput by exploiting instruction-level parallelism and
39712      therefore approximate more closely a non-profiled build. */
39713   JITTER_PROFILE_COUNT_UPDATE
39714      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39715       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39716 #endif
39717 
39718 /* User-specified code, instruction-beginning-c part: beginning. */
39719 
39720 
39721 /* User-specified code, instruction-beginning-c part: end */
39722 
39723 
39724     /* User code for *branch-if-null/fR*-no-fast-branches . */
39725 
39726     jitterlisp_object top = JITTER_TOP_MAINSTACK();
39727     JITTER_DROP_MAINSTACK();
39728     JITTER_BRANCH_FAST_IF_EQUAL(top, JITTERLISP_EMPTY_LIST, JITTER_ARGF0);
39729 
39730     /* End of the user code for *branch-if-null/fR*-no-fast-branches . */
39731 
39732 /* User-specified code, instruction-end-c part: beginning. */
39733 
39734 
39735 /* User-specified code, instruction-end-c part: end */
39736 
39737 #ifdef JITTER_REPLICATE
39738     /* Advance the instruction pointer, if any, to skip residuals;
39739        then jump back to replicated code. */
39740     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
39741     JITTER_SKIP_RESIDUALS_;
39742     goto * _jitter_back_to_replicated_code_pointer;
39743 #endif // #ifdef JITTER_REPLICATE
39744 
39745     /* Undefine the *branch-if-null/fR*-no-fast-branches argument macros so they can't be used
39746        by mistake in the instruction body coming next. */
39747 #   undef JITTER_SLOW_REGISTER_OFFSET0
39748 #   undef JITTER_ARG0
39749 #   undef JITTER_ARGN0
39750 #   undef JITTER_ARGU0
39751 #   undef JITTER_ARGP0
39752 #   undef JITTER_ARGF0
39753 
39754 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
39755 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
39756 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
39757 
39758   }
39759 #ifndef JITTER_REPLICATE
39760  JITTER_INSTRUCTION_EPILOG_(*branch-if-null/fR*-no-fast-branches, _Abranch_mif_mnull__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
39761 #endif // #ifndef JITTER_REPLICATE
39762 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
39763 
39764   JITTER_INSTRUCTION_PROLOG_(*branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches, _Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches, cold)
39765   {
39766     /* This specialized instruction is a replacement. */
39767 #   undef JITTER_BRANCH_FAST
39768 #   define JITTER_BRANCH_FAST JITTER_BRANCH
39769 #   undef JITTER_BRANCH_FAST_IF_ZERO
39770 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
39771 #   undef JITTER_BRANCH_FAST_IF_NONZERO
39772 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
39773 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
39774 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
39775 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
39776 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
39777 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
39778 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
39779 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
39780 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
39781 #   undef JITTER_BRANCH_FAST_IF_EQUAL
39782 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
39783 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
39784 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
39785 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
39786 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
39787 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
39788 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
39789 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
39790 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
39791 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
39792 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
39793 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
39794 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
39795 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
39796 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
39797 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
39798 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
39799 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
39800 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
39801 #   undef JITTER_BRANCH_FAST_IF_AND
39802 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
39803 #   undef JITTER_BRANCH_FAST_IF_NOTAND
39804 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
39805 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
39806 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
39807 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
39808 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
39809 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
39810 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
39811 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
39812 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
39813 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
39814 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
39815 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
39816 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
39817 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
39818 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
39819 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
39820 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
39821 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
39822 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
39823 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
39824 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
39825 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
39826 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
39827 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
39828 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
39829 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
39830 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
39831     /* This specialized instruction is non-relocatable.
39832        Its 2-th argument, a literal, is the return address where to jump
39833        at the end, back to relocated code. */
39834 
39835 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       217
39836 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches
39837 
39838 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches
39839 
39840   /* The residual arity for this instruction does not depend on fast labels. */
39841   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
39842 
39843   /* Define argument-access macros for *branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches . */
39844 #ifdef JITTER_HAVE_PATCH_IN
39845   /* Define argument-access macros assuming that fast branches are enabled. */
39846     /* The 0th argument is a slow (therefore residual, passed as an offset)
39847         register. */
39848   /* Define a macro expanding to the slow register offset. */
39849 #if defined(JITTER_DISPATCH_NO_THREADING)
39850 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
39851 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
39852 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
39853 #else
39854 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
39855 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39856   /* Define a macro expanding to an l-value for the VM register content. */
39857 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
39858 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39859 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39860 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39861 
39862     /* The 1th argument is a residual label. */
39863 #if defined(JITTER_DISPATCH_NO_THREADING)
39864 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
39865     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
39866 #elif defined (JITTER_REPLICATE)
39867 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
39868 #else
39869 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
39870 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39871 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
39872 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
39873 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
39874 #   define JITTER_ARGF1 JITTER_ARGP1
39875 
39876     /* The 2th argument is a residual label. */
39877 #if defined(JITTER_DISPATCH_NO_THREADING)
39878 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
39879     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
39880 #elif defined (JITTER_REPLICATE)
39881 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
39882 #else
39883 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
39884 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39885 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
39886 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
39887 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
39888 #   define JITTER_ARGF2 JITTER_ARGP2
39889 
39890 #else
39891   /* Define argument-access macros assuming that fast branches are disabled. */
39892     /* The 0th argument is a slow (therefore residual, passed as an offset)
39893         register. */
39894   /* Define a macro expanding to the slow register offset. */
39895 #if defined(JITTER_DISPATCH_NO_THREADING)
39896 # define JITTER_SLOW_REGISTER_OFFSET0 (JITTER_RESIDUAL_ARGUMENT_0.fixnum)
39897 #elif defined (JITTER_DISPATCH_MINIMAL_THREADING)
39898 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[0]).fixnum)
39899 #else
39900 # define JITTER_SLOW_REGISTER_OFFSET0 ((((union jitter_word*)jitter_ip)[1]).fixnum)
39901 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39902   /* Define a macro expanding to an l-value for the VM register content. */
39903 #   define JITTER_ARG0  JITTER_SLOW_REGISTER_FROM_OFFSET(r, JITTER_SLOW_REGISTER_OFFSET0)
39904 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
39905 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
39906 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
39907 #   define JITTER_ARGF0 JITTER_ARGP0
39908 
39909     /* The 1th argument is a residual label. */
39910 #if defined(JITTER_DISPATCH_NO_THREADING)
39911 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
39912     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
39913 #elif defined (JITTER_REPLICATE)
39914 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
39915 #else
39916 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
39917 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39918 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
39919 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
39920 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
39921 #   define JITTER_ARGF1 JITTER_ARGP1
39922 
39923     /* The 2th argument is a residual label. */
39924 #if defined(JITTER_DISPATCH_NO_THREADING)
39925 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
39926     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
39927 #elif defined (JITTER_REPLICATE)
39928 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
39929 #else
39930 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
39931 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
39932 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
39933 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
39934 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
39935 #   define JITTER_ARGF2 JITTER_ARGP2
39936 
39937 # endif // #ifdef JITTER_HAVE_PATCH_IN
39938 
39939 #ifdef JITTER_REPLICATE
39940     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
39941        it on the stack rather than in read-only memory.  I had to do this to prevent
39942        a GCC 8 snapshot on SH from being too clever. */
39943     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39944     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
39945        in memory, as a 16-bit constant; and since it reads it with a PC-relative
39946        load the relocated part crashes.
39947                  mov.w     .L1667,r0
39948                  mov.l     @(r0,r15),r1
39949                  jmp       @r1
39950        r15 is the stack pointer.  The constant at .L1667 is
39951           .L1667:
39952                  .short    232
39953        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
39954        can't work as an immediate.  Shall I keep these code pointers as a single array?
39955        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
39956        but the problem will be the same. */
39957     /* Jump to non-relocatable code. */
39958     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
39959 
39960     /* Here the residual arity is given as zero: it's too late to
39961        skip residuals, since we've already jumped and this code is
39962        unreachable.  The instruction pointer, if any, is advanced
39963        in the non-relocatable code. */
39964     JITTER_INSTRUCTION_EPILOG_(*branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches, _Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches, 0)
39965 
39966     /* Relocated code will jump to this label in non-relocated code. */
39967   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
39968     JITTER_COMMENT_IN_ASM_("*branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches non-relocatable code");
39969 #endif // #ifdef JITTER_REPLICATE
39970 #if defined (JITTER_PROFILE_SAMPLE)
39971   JITTER_PROFILE_SAMPLE_UPDATE
39972      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39973       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39974   /* Force the compiler not move sample-profiling instrumentation
39975      beyond this point; this way the actual user code is timed.
39976      This is still not perfect, as residuals are materialised before
39977      we arrive here, but should be adequate at least for slow VM
39978      instructions. */
39979   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
39980 #endif
39981 #if defined (JITTER_PROFILE_COUNT)
39982   /* Notice that, differently from the code above, this
39983      instrumentation code *can* be reordered freely: as long as a
39984      VM instruction is counted, the count increment can be placed
39985      anyehere.  Let GCC move this code and possibly achieve better
39986      throughput by exploiting instruction-level parallelism and
39987      therefore approximate more closely a non-profiled build. */
39988   JITTER_PROFILE_COUNT_UPDATE
39989      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
39990       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
39991 #endif
39992 
39993 /* User-specified code, instruction-beginning-c part: beginning. */
39994 
39995 
39996 /* User-specified code, instruction-beginning-c part: end */
39997 
39998 
39999     /* User code for *branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches . */
40000 
40001 #if ! defined (JITTERLISP_UNSAFE)
40002     JITTERLISP_BRANCH_FAST_UNLESS_FIXNUM (JITTER_ARG0, JITTER_ARGF2);
40003 #endif
40004     JITTER_BRANCH_FAST_IF_NOTEQUAL(JITTER_ARG0, JITTERLISP_FIXNUM_ENCODE(0),
40005                                    JITTER_ARGF1);
40006 
40007     /* End of the user code for *branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches . */
40008 
40009 /* User-specified code, instruction-end-c part: beginning. */
40010 
40011 
40012 /* User-specified code, instruction-end-c part: end */
40013 
40014 #ifdef JITTER_REPLICATE
40015     /* Advance the instruction pointer, if any, to skip residuals;
40016        then jump back to replicated code. */
40017     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP2;
40018     JITTER_SKIP_RESIDUALS_;
40019     goto * _jitter_back_to_replicated_code_pointer;
40020 #endif // #ifdef JITTER_REPLICATE
40021 
40022     /* Undefine the *branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches argument macros so they can't be used
40023        by mistake in the instruction body coming next. */
40024 #   undef JITTER_SLOW_REGISTER_OFFSET0
40025 #   undef JITTER_ARG0
40026 #   undef JITTER_ARGN0
40027 #   undef JITTER_ARGU0
40028 #   undef JITTER_ARGP0
40029 #   undef JITTER_ARGF0
40030 #   undef JITTER_SLOW_REGISTER_OFFSET1
40031 #   undef JITTER_ARG1
40032 #   undef JITTER_ARGN1
40033 #   undef JITTER_ARGU1
40034 #   undef JITTER_ARGP1
40035 #   undef JITTER_ARGF1
40036 #   undef JITTER_SLOW_REGISTER_OFFSET2
40037 #   undef JITTER_ARG2
40038 #   undef JITTER_ARGN2
40039 #   undef JITTER_ARGU2
40040 #   undef JITTER_ARGP2
40041 #   undef JITTER_ARGF2
40042 
40043 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40044 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40045 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40046 
40047   }
40048 #ifndef JITTER_REPLICATE
40049  JITTER_INSTRUCTION_EPILOG_(*branch-if-register-non-zero/%rR/fR/fR*-no-fast-branches, _Abranch_mif_mregister_mnon_mzero___rrR__fR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40050 #endif // #ifndef JITTER_REPLICATE
40051 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40052 
40053   JITTER_INSTRUCTION_PROLOG_(*branch-if-true/fR*-no-fast-branches, _Abranch_mif_mtrue__fR_A_mno_mfast_mbranches, hot)
40054   {
40055     /* This specialized instruction is a replacement. */
40056 #   undef JITTER_BRANCH_FAST
40057 #   define JITTER_BRANCH_FAST JITTER_BRANCH
40058 #   undef JITTER_BRANCH_FAST_IF_ZERO
40059 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
40060 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40061 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
40062 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40063 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
40064 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40065 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
40066 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40067 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
40068 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40069 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
40070 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40071 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
40072 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40073 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
40074 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40075 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
40076 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40077 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
40078 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40079 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
40080 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40081 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
40082 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40083 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
40084 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40085 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
40086 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40087 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
40088 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40089 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
40090 #   undef JITTER_BRANCH_FAST_IF_AND
40091 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
40092 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40093 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
40094 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40095 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
40096 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40097 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
40098 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40099 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
40100 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40101 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
40102 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40103 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
40104 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40105 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
40106 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40107 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
40108 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40109 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
40110 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40111 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
40112 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40113 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
40114 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40115 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
40116 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40117 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
40118 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40119 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
40120     /* This specialized instruction is non-relocatable.
40121        Its 0-th argument, a literal, is the return address where to jump
40122        at the end, back to relocated code. */
40123 
40124 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       218
40125 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *branch-if-true/fR*-no-fast-branches
40126 
40127 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Abranch_mif_mtrue__fR_A_mno_mfast_mbranches
40128 
40129   /* The residual arity for this instruction does not depend on fast labels. */
40130   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
40131 
40132   /* Define argument-access macros for *branch-if-true/fR*-no-fast-branches . */
40133 #ifdef JITTER_HAVE_PATCH_IN
40134   /* Define argument-access macros assuming that fast branches are enabled. */
40135     /* The 0th argument is a residual label. */
40136 #if defined(JITTER_DISPATCH_NO_THREADING)
40137 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
40138     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40139 #elif defined (JITTER_REPLICATE)
40140 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
40141 #else
40142 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
40143 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40144 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40145 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40146 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40147 #   define JITTER_ARGF0 JITTER_ARGP0
40148 
40149 #else
40150   /* Define argument-access macros assuming that fast branches are disabled. */
40151     /* The 0th argument is a residual label. */
40152 #if defined(JITTER_DISPATCH_NO_THREADING)
40153 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
40154     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40155 #elif defined (JITTER_REPLICATE)
40156 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
40157 #else
40158 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
40159 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40160 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40161 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40162 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40163 #   define JITTER_ARGF0 JITTER_ARGP0
40164 
40165 # endif // #ifdef JITTER_HAVE_PATCH_IN
40166 
40167 #ifdef JITTER_REPLICATE
40168     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
40169        it on the stack rather than in read-only memory.  I had to do this to prevent
40170        a GCC 8 snapshot on SH from being too clever. */
40171     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40172     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
40173        in memory, as a 16-bit constant; and since it reads it with a PC-relative
40174        load the relocated part crashes.
40175                  mov.w     .L1667,r0
40176                  mov.l     @(r0,r15),r1
40177                  jmp       @r1
40178        r15 is the stack pointer.  The constant at .L1667 is
40179           .L1667:
40180                  .short    232
40181        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
40182        can't work as an immediate.  Shall I keep these code pointers as a single array?
40183        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
40184        but the problem will be the same. */
40185     /* Jump to non-relocatable code. */
40186     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40187 
40188     /* Here the residual arity is given as zero: it's too late to
40189        skip residuals, since we've already jumped and this code is
40190        unreachable.  The instruction pointer, if any, is advanced
40191        in the non-relocatable code. */
40192     JITTER_INSTRUCTION_EPILOG_(*branch-if-true/fR*-no-fast-branches, _Abranch_mif_mtrue__fR_A_mno_mfast_mbranches, 0)
40193 
40194     /* Relocated code will jump to this label in non-relocated code. */
40195   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
40196     JITTER_COMMENT_IN_ASM_("*branch-if-true/fR*-no-fast-branches non-relocatable code");
40197 #endif // #ifdef JITTER_REPLICATE
40198 #if defined (JITTER_PROFILE_SAMPLE)
40199   JITTER_PROFILE_SAMPLE_UPDATE
40200      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40201       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40202   /* Force the compiler not move sample-profiling instrumentation
40203      beyond this point; this way the actual user code is timed.
40204      This is still not perfect, as residuals are materialised before
40205      we arrive here, but should be adequate at least for slow VM
40206      instructions. */
40207   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40208 #endif
40209 #if defined (JITTER_PROFILE_COUNT)
40210   /* Notice that, differently from the code above, this
40211      instrumentation code *can* be reordered freely: as long as a
40212      VM instruction is counted, the count increment can be placed
40213      anyehere.  Let GCC move this code and possibly achieve better
40214      throughput by exploiting instruction-level parallelism and
40215      therefore approximate more closely a non-profiled build. */
40216   JITTER_PROFILE_COUNT_UPDATE
40217      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40218       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40219 #endif
40220 
40221 /* User-specified code, instruction-beginning-c part: beginning. */
40222 
40223 
40224 /* User-specified code, instruction-beginning-c part: end */
40225 
40226 
40227     /* User code for *branch-if-true/fR*-no-fast-branches . */
40228 
40229     jitterlisp_object top = JITTER_TOP_MAINSTACK();
40230     JITTER_DROP_MAINSTACK();
40231     JITTER_BRANCH_FAST_IF_NOTEQUAL(top, JITTERLISP_FALSE, JITTER_ARGF0);
40232 
40233     /* End of the user code for *branch-if-true/fR*-no-fast-branches . */
40234 
40235 /* User-specified code, instruction-end-c part: beginning. */
40236 
40237 
40238 /* User-specified code, instruction-end-c part: end */
40239 
40240 #ifdef JITTER_REPLICATE
40241     /* Advance the instruction pointer, if any, to skip residuals;
40242        then jump back to replicated code. */
40243     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
40244     JITTER_SKIP_RESIDUALS_;
40245     goto * _jitter_back_to_replicated_code_pointer;
40246 #endif // #ifdef JITTER_REPLICATE
40247 
40248     /* Undefine the *branch-if-true/fR*-no-fast-branches argument macros so they can't be used
40249        by mistake in the instruction body coming next. */
40250 #   undef JITTER_SLOW_REGISTER_OFFSET0
40251 #   undef JITTER_ARG0
40252 #   undef JITTER_ARGN0
40253 #   undef JITTER_ARGU0
40254 #   undef JITTER_ARGP0
40255 #   undef JITTER_ARGF0
40256 
40257 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40258 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40259 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40260 
40261   }
40262 #ifndef JITTER_REPLICATE
40263  JITTER_INSTRUCTION_EPILOG_(*branch-if-true/fR*-no-fast-branches, _Abranch_mif_mtrue__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40264 #endif // #ifndef JITTER_REPLICATE
40265 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40266 
40267   JITTER_INSTRUCTION_PROLOG_(*check-closure/fR*-no-fast-branches, _Acheck_mclosure__fR_A_mno_mfast_mbranches, hot)
40268   {
40269     /* This specialized instruction is a replacement. */
40270 #   undef JITTER_BRANCH_FAST
40271 #   define JITTER_BRANCH_FAST JITTER_BRANCH
40272 #   undef JITTER_BRANCH_FAST_IF_ZERO
40273 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
40274 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40275 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
40276 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40277 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
40278 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40279 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
40280 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40281 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
40282 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40283 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
40284 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40285 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
40286 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40287 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
40288 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40289 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
40290 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40291 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
40292 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40293 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
40294 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40295 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
40296 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40297 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
40298 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40299 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
40300 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40301 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
40302 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40303 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
40304 #   undef JITTER_BRANCH_FAST_IF_AND
40305 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
40306 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40307 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
40308 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40309 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
40310 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40311 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
40312 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40313 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
40314 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40315 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
40316 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40317 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
40318 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40319 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
40320 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40321 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
40322 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40323 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
40324 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40325 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
40326 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40327 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
40328 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40329 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
40330 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40331 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
40332 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40333 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
40334     /* This specialized instruction is non-relocatable.
40335        Its 0-th argument, a literal, is the return address where to jump
40336        at the end, back to relocated code. */
40337 
40338 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       219
40339 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-closure/fR*-no-fast-branches
40340 
40341 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_mclosure__fR_A_mno_mfast_mbranches
40342 
40343   /* The residual arity for this instruction does not depend on fast labels. */
40344   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
40345 
40346   /* Define argument-access macros for *check-closure/fR*-no-fast-branches . */
40347 #ifdef JITTER_HAVE_PATCH_IN
40348   /* Define argument-access macros assuming that fast branches are enabled. */
40349     /* The 0th argument is a residual label. */
40350 #if defined(JITTER_DISPATCH_NO_THREADING)
40351 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
40352     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40353 #elif defined (JITTER_REPLICATE)
40354 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
40355 #else
40356 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
40357 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40358 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40359 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40360 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40361 #   define JITTER_ARGF0 JITTER_ARGP0
40362 
40363 #else
40364   /* Define argument-access macros assuming that fast branches are disabled. */
40365     /* The 0th argument is a residual label. */
40366 #if defined(JITTER_DISPATCH_NO_THREADING)
40367 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
40368     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40369 #elif defined (JITTER_REPLICATE)
40370 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
40371 #else
40372 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
40373 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40374 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40375 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40376 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40377 #   define JITTER_ARGF0 JITTER_ARGP0
40378 
40379 # endif // #ifdef JITTER_HAVE_PATCH_IN
40380 
40381 #ifdef JITTER_REPLICATE
40382     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
40383        it on the stack rather than in read-only memory.  I had to do this to prevent
40384        a GCC 8 snapshot on SH from being too clever. */
40385     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40386     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
40387        in memory, as a 16-bit constant; and since it reads it with a PC-relative
40388        load the relocated part crashes.
40389                  mov.w     .L1667,r0
40390                  mov.l     @(r0,r15),r1
40391                  jmp       @r1
40392        r15 is the stack pointer.  The constant at .L1667 is
40393           .L1667:
40394                  .short    232
40395        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
40396        can't work as an immediate.  Shall I keep these code pointers as a single array?
40397        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
40398        but the problem will be the same. */
40399     /* Jump to non-relocatable code. */
40400     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40401 
40402     /* Here the residual arity is given as zero: it's too late to
40403        skip residuals, since we've already jumped and this code is
40404        unreachable.  The instruction pointer, if any, is advanced
40405        in the non-relocatable code. */
40406     JITTER_INSTRUCTION_EPILOG_(*check-closure/fR*-no-fast-branches, _Acheck_mclosure__fR_A_mno_mfast_mbranches, 0)
40407 
40408     /* Relocated code will jump to this label in non-relocated code. */
40409   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
40410     JITTER_COMMENT_IN_ASM_("*check-closure/fR*-no-fast-branches non-relocatable code");
40411 #endif // #ifdef JITTER_REPLICATE
40412 #if defined (JITTER_PROFILE_SAMPLE)
40413   JITTER_PROFILE_SAMPLE_UPDATE
40414      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40415       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40416   /* Force the compiler not move sample-profiling instrumentation
40417      beyond this point; this way the actual user code is timed.
40418      This is still not perfect, as residuals are materialised before
40419      we arrive here, but should be adequate at least for slow VM
40420      instructions. */
40421   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40422 #endif
40423 #if defined (JITTER_PROFILE_COUNT)
40424   /* Notice that, differently from the code above, this
40425      instrumentation code *can* be reordered freely: as long as a
40426      VM instruction is counted, the count increment can be placed
40427      anyehere.  Let GCC move this code and possibly achieve better
40428      throughput by exploiting instruction-level parallelism and
40429      therefore approximate more closely a non-profiled build. */
40430   JITTER_PROFILE_COUNT_UPDATE
40431      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40432       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40433 #endif
40434 
40435 /* User-specified code, instruction-beginning-c part: beginning. */
40436 
40437 
40438 /* User-specified code, instruction-beginning-c part: end */
40439 
40440 
40441     /* User code for *check-closure/fR*-no-fast-branches . */
40442 
40443 #   ifndef JITTERLISP_UNSAFE
40444       jitterlisp_object top = JITTER_TOP_MAINSTACK();
40445       if (! JITTERLISP_IS_CLOSURE(top))
40446         JITTER_BRANCH_FAST(JITTER_ARGF0);
40447 #   endif // #ifndef JITTERLISP_UNSAFE
40448 
40449     /* End of the user code for *check-closure/fR*-no-fast-branches . */
40450 
40451 /* User-specified code, instruction-end-c part: beginning. */
40452 
40453 
40454 /* User-specified code, instruction-end-c part: end */
40455 
40456 #ifdef JITTER_REPLICATE
40457     /* Advance the instruction pointer, if any, to skip residuals;
40458        then jump back to replicated code. */
40459     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
40460     JITTER_SKIP_RESIDUALS_;
40461     goto * _jitter_back_to_replicated_code_pointer;
40462 #endif // #ifdef JITTER_REPLICATE
40463 
40464     /* Undefine the *check-closure/fR*-no-fast-branches argument macros so they can't be used
40465        by mistake in the instruction body coming next. */
40466 #   undef JITTER_SLOW_REGISTER_OFFSET0
40467 #   undef JITTER_ARG0
40468 #   undef JITTER_ARGN0
40469 #   undef JITTER_ARGU0
40470 #   undef JITTER_ARGP0
40471 #   undef JITTER_ARGF0
40472 
40473 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40474 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40475 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40476 
40477   }
40478 #ifndef JITTER_REPLICATE
40479  JITTER_INSTRUCTION_EPILOG_(*check-closure/fR*-no-fast-branches, _Acheck_mclosure__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40480 #endif // #ifndef JITTER_REPLICATE
40481 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40482 
40483   JITTER_INSTRUCTION_PROLOG_(*check-global-defined/nR/fR*-no-fast-branches, _Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches, cold)
40484   {
40485     /* This specialized instruction is a replacement. */
40486 #   undef JITTER_BRANCH_FAST
40487 #   define JITTER_BRANCH_FAST JITTER_BRANCH
40488 #   undef JITTER_BRANCH_FAST_IF_ZERO
40489 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
40490 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40491 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
40492 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40493 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
40494 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40495 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
40496 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40497 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
40498 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40499 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
40500 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40501 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
40502 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40503 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
40504 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40505 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
40506 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40507 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
40508 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40509 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
40510 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40511 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
40512 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40513 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
40514 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40515 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
40516 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40517 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
40518 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40519 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
40520 #   undef JITTER_BRANCH_FAST_IF_AND
40521 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
40522 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40523 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
40524 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40525 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
40526 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40527 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
40528 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40529 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
40530 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40531 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
40532 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40533 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
40534 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40535 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
40536 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40537 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
40538 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40539 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
40540 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40541 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
40542 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40543 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
40544 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40545 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
40546 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40547 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
40548 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40549 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
40550     /* This specialized instruction is non-relocatable.
40551        Its 1-th argument, a literal, is the return address where to jump
40552        at the end, back to relocated code. */
40553 
40554 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       220
40555 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-global-defined/nR/fR*-no-fast-branches
40556 
40557 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches
40558 
40559   /* The residual arity for this instruction does not depend on fast labels. */
40560   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
40561 
40562   /* Define argument-access macros for *check-global-defined/nR/fR*-no-fast-branches . */
40563 #ifdef JITTER_HAVE_PATCH_IN
40564   /* Define argument-access macros assuming that fast branches are enabled. */
40565     /* The 0th argument is a residual literal. */
40566 #if defined(JITTER_DISPATCH_NO_THREADING)
40567 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
40568     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40569 #elif defined (JITTER_REPLICATE)
40570 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
40571 #else
40572 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
40573 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40574 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40575 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40576 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40577 
40578     /* The 1th argument is a residual label. */
40579 #if defined(JITTER_DISPATCH_NO_THREADING)
40580 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
40581     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
40582 #elif defined (JITTER_REPLICATE)
40583 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
40584 #else
40585 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
40586 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40587 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
40588 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
40589 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
40590 #   define JITTER_ARGF1 JITTER_ARGP1
40591 
40592 #else
40593   /* Define argument-access macros assuming that fast branches are disabled. */
40594     /* The 0th argument is a residual literal. */
40595 #if defined(JITTER_DISPATCH_NO_THREADING)
40596 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
40597     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40598 #elif defined (JITTER_REPLICATE)
40599 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
40600 #else
40601 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
40602 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40603 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40604 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40605 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40606 #   define JITTER_ARGF0 JITTER_ARGP0
40607 
40608     /* The 1th argument is a residual label. */
40609 #if defined(JITTER_DISPATCH_NO_THREADING)
40610 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
40611     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
40612 #elif defined (JITTER_REPLICATE)
40613 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
40614 #else
40615 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
40616 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40617 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
40618 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
40619 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
40620 #   define JITTER_ARGF1 JITTER_ARGP1
40621 
40622 # endif // #ifdef JITTER_HAVE_PATCH_IN
40623 
40624 #ifdef JITTER_REPLICATE
40625     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
40626        it on the stack rather than in read-only memory.  I had to do this to prevent
40627        a GCC 8 snapshot on SH from being too clever. */
40628     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40629     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
40630        in memory, as a 16-bit constant; and since it reads it with a PC-relative
40631        load the relocated part crashes.
40632                  mov.w     .L1667,r0
40633                  mov.l     @(r0,r15),r1
40634                  jmp       @r1
40635        r15 is the stack pointer.  The constant at .L1667 is
40636           .L1667:
40637                  .short    232
40638        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
40639        can't work as an immediate.  Shall I keep these code pointers as a single array?
40640        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
40641        but the problem will be the same. */
40642     /* Jump to non-relocatable code. */
40643     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40644 
40645     /* Here the residual arity is given as zero: it's too late to
40646        skip residuals, since we've already jumped and this code is
40647        unreachable.  The instruction pointer, if any, is advanced
40648        in the non-relocatable code. */
40649     JITTER_INSTRUCTION_EPILOG_(*check-global-defined/nR/fR*-no-fast-branches, _Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches, 0)
40650 
40651     /* Relocated code will jump to this label in non-relocated code. */
40652   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
40653     JITTER_COMMENT_IN_ASM_("*check-global-defined/nR/fR*-no-fast-branches non-relocatable code");
40654 #endif // #ifdef JITTER_REPLICATE
40655 #if defined (JITTER_PROFILE_SAMPLE)
40656   JITTER_PROFILE_SAMPLE_UPDATE
40657      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40658       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40659   /* Force the compiler not move sample-profiling instrumentation
40660      beyond this point; this way the actual user code is timed.
40661      This is still not perfect, as residuals are materialised before
40662      we arrive here, but should be adequate at least for slow VM
40663      instructions. */
40664   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40665 #endif
40666 #if defined (JITTER_PROFILE_COUNT)
40667   /* Notice that, differently from the code above, this
40668      instrumentation code *can* be reordered freely: as long as a
40669      VM instruction is counted, the count increment can be placed
40670      anyehere.  Let GCC move this code and possibly achieve better
40671      throughput by exploiting instruction-level parallelism and
40672      therefore approximate more closely a non-profiled build. */
40673   JITTER_PROFILE_COUNT_UPDATE
40674      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40675       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40676 #endif
40677 
40678 /* User-specified code, instruction-beginning-c part: beginning. */
40679 
40680 
40681 /* User-specified code, instruction-beginning-c part: end */
40682 
40683 
40684     /* User code for *check-global-defined/nR/fR*-no-fast-branches . */
40685 
40686 #ifndef JITTERLISP_UNSAFE
40687     jitterlisp_object tagged_symbol = JITTER_ARGN0;
40688     struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
40689     JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
40690                                  JITTER_ARGF1);
40691 #endif // #ifndef JITTERLISP_UNSAFE
40692 
40693     /* End of the user code for *check-global-defined/nR/fR*-no-fast-branches . */
40694 
40695 /* User-specified code, instruction-end-c part: beginning. */
40696 
40697 
40698 /* User-specified code, instruction-end-c part: end */
40699 
40700 #ifdef JITTER_REPLICATE
40701     /* Advance the instruction pointer, if any, to skip residuals;
40702        then jump back to replicated code. */
40703     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
40704     JITTER_SKIP_RESIDUALS_;
40705     goto * _jitter_back_to_replicated_code_pointer;
40706 #endif // #ifdef JITTER_REPLICATE
40707 
40708     /* Undefine the *check-global-defined/nR/fR*-no-fast-branches argument macros so they can't be used
40709        by mistake in the instruction body coming next. */
40710 #   undef JITTER_SLOW_REGISTER_OFFSET0
40711 #   undef JITTER_ARG0
40712 #   undef JITTER_ARGN0
40713 #   undef JITTER_ARGU0
40714 #   undef JITTER_ARGP0
40715 #   undef JITTER_ARGF0
40716 #   undef JITTER_SLOW_REGISTER_OFFSET1
40717 #   undef JITTER_ARG1
40718 #   undef JITTER_ARGN1
40719 #   undef JITTER_ARGU1
40720 #   undef JITTER_ARGP1
40721 #   undef JITTER_ARGF1
40722 
40723 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40724 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40725 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40726 
40727   }
40728 #ifndef JITTER_REPLICATE
40729  JITTER_INSTRUCTION_EPILOG_(*check-global-defined/nR/fR*-no-fast-branches, _Acheck_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40730 #endif // #ifndef JITTER_REPLICATE
40731 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40732 
40733   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n0/fR*-no-fast-branches, _Acheck_min_marity__n0__fR_A_mno_mfast_mbranches, hot)
40734   {
40735     /* This specialized instruction is a replacement. */
40736 #   undef JITTER_BRANCH_FAST
40737 #   define JITTER_BRANCH_FAST JITTER_BRANCH
40738 #   undef JITTER_BRANCH_FAST_IF_ZERO
40739 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
40740 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40741 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
40742 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40743 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
40744 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40745 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
40746 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40747 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
40748 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40749 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
40750 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40751 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
40752 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40753 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
40754 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40755 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
40756 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40757 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
40758 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40759 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
40760 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
40761 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
40762 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
40763 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
40764 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
40765 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
40766 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
40767 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
40768 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
40769 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
40770 #   undef JITTER_BRANCH_FAST_IF_AND
40771 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
40772 #   undef JITTER_BRANCH_FAST_IF_NOTAND
40773 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
40774 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
40775 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
40776 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
40777 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
40778 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
40779 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
40780 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
40781 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
40782 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
40783 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
40784 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
40785 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
40786 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
40787 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
40788 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
40789 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
40790 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
40791 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
40792 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
40793 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
40794 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
40795 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
40796 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
40797 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
40798 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
40799 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
40800     /* This specialized instruction is non-relocatable.
40801        Its 1-th argument, a literal, is the return address where to jump
40802        at the end, back to relocated code. */
40803 
40804 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       221
40805 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n0/fR*-no-fast-branches
40806 
40807 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n0__fR_A_mno_mfast_mbranches
40808 
40809   /* The residual arity for this instruction does not depend on fast labels. */
40810   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
40811 
40812   /* Define argument-access macros for *check-in-arity/n0/fR*-no-fast-branches . */
40813 #ifdef JITTER_HAVE_PATCH_IN
40814   /* Define argument-access macros assuming that fast branches are enabled. */
40815     /* The 0th argument is a nonresidual literal. */
40816 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
40817 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40818 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40819 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40820 
40821     /* The 1th argument is a residual label. */
40822 #if defined(JITTER_DISPATCH_NO_THREADING)
40823 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
40824     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40825 #elif defined (JITTER_REPLICATE)
40826 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
40827 #else
40828 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
40829 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40830 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
40831 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
40832 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
40833 #   define JITTER_ARGF1 JITTER_ARGP1
40834 
40835 #else
40836   /* Define argument-access macros assuming that fast branches are disabled. */
40837     /* The 0th argument is a nonresidual literal. */
40838 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
40839 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
40840 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
40841 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
40842 #   define JITTER_ARGF0 JITTER_ARGP0
40843 
40844     /* The 1th argument is a residual label. */
40845 #if defined(JITTER_DISPATCH_NO_THREADING)
40846 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
40847     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
40848 #elif defined (JITTER_REPLICATE)
40849 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
40850 #else
40851 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
40852 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
40853 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
40854 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
40855 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
40856 #   define JITTER_ARGF1 JITTER_ARGP1
40857 
40858 # endif // #ifdef JITTER_HAVE_PATCH_IN
40859 
40860 #ifdef JITTER_REPLICATE
40861     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
40862        it on the stack rather than in read-only memory.  I had to do this to prevent
40863        a GCC 8 snapshot on SH from being too clever. */
40864     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40865     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
40866        in memory, as a 16-bit constant; and since it reads it with a PC-relative
40867        load the relocated part crashes.
40868                  mov.w     .L1667,r0
40869                  mov.l     @(r0,r15),r1
40870                  jmp       @r1
40871        r15 is the stack pointer.  The constant at .L1667 is
40872           .L1667:
40873                  .short    232
40874        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
40875        can't work as an immediate.  Shall I keep these code pointers as a single array?
40876        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
40877        but the problem will be the same. */
40878     /* Jump to non-relocatable code. */
40879     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
40880 
40881     /* Here the residual arity is given as zero: it's too late to
40882        skip residuals, since we've already jumped and this code is
40883        unreachable.  The instruction pointer, if any, is advanced
40884        in the non-relocatable code. */
40885     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n0/fR*-no-fast-branches, _Acheck_min_marity__n0__fR_A_mno_mfast_mbranches, 0)
40886 
40887     /* Relocated code will jump to this label in non-relocated code. */
40888   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
40889     JITTER_COMMENT_IN_ASM_("*check-in-arity/n0/fR*-no-fast-branches non-relocatable code");
40890 #endif // #ifdef JITTER_REPLICATE
40891 #if defined (JITTER_PROFILE_SAMPLE)
40892   JITTER_PROFILE_SAMPLE_UPDATE
40893      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40894       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40895   /* Force the compiler not move sample-profiling instrumentation
40896      beyond this point; this way the actual user code is timed.
40897      This is still not perfect, as residuals are materialised before
40898      we arrive here, but should be adequate at least for slow VM
40899      instructions. */
40900   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
40901 #endif
40902 #if defined (JITTER_PROFILE_COUNT)
40903   /* Notice that, differently from the code above, this
40904      instrumentation code *can* be reordered freely: as long as a
40905      VM instruction is counted, the count increment can be placed
40906      anyehere.  Let GCC move this code and possibly achieve better
40907      throughput by exploiting instruction-level parallelism and
40908      therefore approximate more closely a non-profiled build. */
40909   JITTER_PROFILE_COUNT_UPDATE
40910      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
40911       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
40912 #endif
40913 
40914 /* User-specified code, instruction-beginning-c part: beginning. */
40915 
40916 
40917 /* User-specified code, instruction-beginning-c part: end */
40918 
40919 
40920     /* User code for *check-in-arity/n0/fR*-no-fast-branches . */
40921 
40922 #   ifndef JITTERLISP_UNSAFE
40923       /* Here we can assume that the top object is a closure, without checking:
40924          we either already performed a type check, or the compiler decided it
40925          wasn't necessary. */
40926       jitterlisp_object top = JITTER_TOP_MAINSTACK();
40927       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
40928 
40929       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
40930 #   endif // #ifndef JITTERLISP_UNSAFE
40931 
40932     /* End of the user code for *check-in-arity/n0/fR*-no-fast-branches . */
40933 
40934 /* User-specified code, instruction-end-c part: beginning. */
40935 
40936 
40937 /* User-specified code, instruction-end-c part: end */
40938 
40939 #ifdef JITTER_REPLICATE
40940     /* Advance the instruction pointer, if any, to skip residuals;
40941        then jump back to replicated code. */
40942     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
40943     JITTER_SKIP_RESIDUALS_;
40944     goto * _jitter_back_to_replicated_code_pointer;
40945 #endif // #ifdef JITTER_REPLICATE
40946 
40947     /* Undefine the *check-in-arity/n0/fR*-no-fast-branches argument macros so they can't be used
40948        by mistake in the instruction body coming next. */
40949 #   undef JITTER_SLOW_REGISTER_OFFSET0
40950 #   undef JITTER_ARG0
40951 #   undef JITTER_ARGN0
40952 #   undef JITTER_ARGU0
40953 #   undef JITTER_ARGP0
40954 #   undef JITTER_ARGF0
40955 #   undef JITTER_SLOW_REGISTER_OFFSET1
40956 #   undef JITTER_ARG1
40957 #   undef JITTER_ARGN1
40958 #   undef JITTER_ARGU1
40959 #   undef JITTER_ARGP1
40960 #   undef JITTER_ARGF1
40961 
40962 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
40963 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
40964 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
40965 
40966   }
40967 #ifndef JITTER_REPLICATE
40968  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n0/fR*-no-fast-branches, _Acheck_min_marity__n0__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
40969 #endif // #ifndef JITTER_REPLICATE
40970 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
40971 
40972   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n1/fR*-no-fast-branches, _Acheck_min_marity__n1__fR_A_mno_mfast_mbranches, hot)
40973   {
40974     /* This specialized instruction is a replacement. */
40975 #   undef JITTER_BRANCH_FAST
40976 #   define JITTER_BRANCH_FAST JITTER_BRANCH
40977 #   undef JITTER_BRANCH_FAST_IF_ZERO
40978 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
40979 #   undef JITTER_BRANCH_FAST_IF_NONZERO
40980 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
40981 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
40982 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
40983 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
40984 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
40985 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
40986 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
40987 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
40988 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
40989 #   undef JITTER_BRANCH_FAST_IF_EQUAL
40990 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
40991 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
40992 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
40993 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
40994 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
40995 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
40996 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
40997 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
40998 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
40999 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41000 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
41001 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41002 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
41003 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41004 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
41005 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41006 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
41007 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41008 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
41009 #   undef JITTER_BRANCH_FAST_IF_AND
41010 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
41011 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41012 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
41013 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41014 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
41015 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41016 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
41017 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41018 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
41019 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41020 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
41021 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41022 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
41023 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41024 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
41025 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41026 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
41027 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41028 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
41029 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41030 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
41031 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41032 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
41033 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41034 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
41035 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41036 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
41037 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41038 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
41039     /* This specialized instruction is non-relocatable.
41040        Its 1-th argument, a literal, is the return address where to jump
41041        at the end, back to relocated code. */
41042 
41043 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       222
41044 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n1/fR*-no-fast-branches
41045 
41046 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n1__fR_A_mno_mfast_mbranches
41047 
41048   /* The residual arity for this instruction does not depend on fast labels. */
41049   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
41050 
41051   /* Define argument-access macros for *check-in-arity/n1/fR*-no-fast-branches . */
41052 #ifdef JITTER_HAVE_PATCH_IN
41053   /* Define argument-access macros assuming that fast branches are enabled. */
41054     /* The 0th argument is a nonresidual literal. */
41055 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
41056 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41057 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41058 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41059 
41060     /* The 1th argument is a residual label. */
41061 #if defined(JITTER_DISPATCH_NO_THREADING)
41062 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41063     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41064 #elif defined (JITTER_REPLICATE)
41065 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41066 #else
41067 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41068 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41069 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41070 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41071 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41072 #   define JITTER_ARGF1 JITTER_ARGP1
41073 
41074 #else
41075   /* Define argument-access macros assuming that fast branches are disabled. */
41076     /* The 0th argument is a nonresidual literal. */
41077 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
41078 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41079 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41080 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41081 #   define JITTER_ARGF0 JITTER_ARGP0
41082 
41083     /* The 1th argument is a residual label. */
41084 #if defined(JITTER_DISPATCH_NO_THREADING)
41085 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41086     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41087 #elif defined (JITTER_REPLICATE)
41088 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41089 #else
41090 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41091 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41092 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41093 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41094 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41095 #   define JITTER_ARGF1 JITTER_ARGP1
41096 
41097 # endif // #ifdef JITTER_HAVE_PATCH_IN
41098 
41099 #ifdef JITTER_REPLICATE
41100     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
41101        it on the stack rather than in read-only memory.  I had to do this to prevent
41102        a GCC 8 snapshot on SH from being too clever. */
41103     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41104     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
41105        in memory, as a 16-bit constant; and since it reads it with a PC-relative
41106        load the relocated part crashes.
41107                  mov.w     .L1667,r0
41108                  mov.l     @(r0,r15),r1
41109                  jmp       @r1
41110        r15 is the stack pointer.  The constant at .L1667 is
41111           .L1667:
41112                  .short    232
41113        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
41114        can't work as an immediate.  Shall I keep these code pointers as a single array?
41115        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
41116        but the problem will be the same. */
41117     /* Jump to non-relocatable code. */
41118     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41119 
41120     /* Here the residual arity is given as zero: it's too late to
41121        skip residuals, since we've already jumped and this code is
41122        unreachable.  The instruction pointer, if any, is advanced
41123        in the non-relocatable code. */
41124     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n1/fR*-no-fast-branches, _Acheck_min_marity__n1__fR_A_mno_mfast_mbranches, 0)
41125 
41126     /* Relocated code will jump to this label in non-relocated code. */
41127   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
41128     JITTER_COMMENT_IN_ASM_("*check-in-arity/n1/fR*-no-fast-branches non-relocatable code");
41129 #endif // #ifdef JITTER_REPLICATE
41130 #if defined (JITTER_PROFILE_SAMPLE)
41131   JITTER_PROFILE_SAMPLE_UPDATE
41132      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41133       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41134   /* Force the compiler not move sample-profiling instrumentation
41135      beyond this point; this way the actual user code is timed.
41136      This is still not perfect, as residuals are materialised before
41137      we arrive here, but should be adequate at least for slow VM
41138      instructions. */
41139   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41140 #endif
41141 #if defined (JITTER_PROFILE_COUNT)
41142   /* Notice that, differently from the code above, this
41143      instrumentation code *can* be reordered freely: as long as a
41144      VM instruction is counted, the count increment can be placed
41145      anyehere.  Let GCC move this code and possibly achieve better
41146      throughput by exploiting instruction-level parallelism and
41147      therefore approximate more closely a non-profiled build. */
41148   JITTER_PROFILE_COUNT_UPDATE
41149      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41150       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41151 #endif
41152 
41153 /* User-specified code, instruction-beginning-c part: beginning. */
41154 
41155 
41156 /* User-specified code, instruction-beginning-c part: end */
41157 
41158 
41159     /* User code for *check-in-arity/n1/fR*-no-fast-branches . */
41160 
41161 #   ifndef JITTERLISP_UNSAFE
41162       /* Here we can assume that the top object is a closure, without checking:
41163          we either already performed a type check, or the compiler decided it
41164          wasn't necessary. */
41165       jitterlisp_object top = JITTER_TOP_MAINSTACK();
41166       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
41167 
41168       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
41169 #   endif // #ifndef JITTERLISP_UNSAFE
41170 
41171     /* End of the user code for *check-in-arity/n1/fR*-no-fast-branches . */
41172 
41173 /* User-specified code, instruction-end-c part: beginning. */
41174 
41175 
41176 /* User-specified code, instruction-end-c part: end */
41177 
41178 #ifdef JITTER_REPLICATE
41179     /* Advance the instruction pointer, if any, to skip residuals;
41180        then jump back to replicated code. */
41181     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
41182     JITTER_SKIP_RESIDUALS_;
41183     goto * _jitter_back_to_replicated_code_pointer;
41184 #endif // #ifdef JITTER_REPLICATE
41185 
41186     /* Undefine the *check-in-arity/n1/fR*-no-fast-branches argument macros so they can't be used
41187        by mistake in the instruction body coming next. */
41188 #   undef JITTER_SLOW_REGISTER_OFFSET0
41189 #   undef JITTER_ARG0
41190 #   undef JITTER_ARGN0
41191 #   undef JITTER_ARGU0
41192 #   undef JITTER_ARGP0
41193 #   undef JITTER_ARGF0
41194 #   undef JITTER_SLOW_REGISTER_OFFSET1
41195 #   undef JITTER_ARG1
41196 #   undef JITTER_ARGN1
41197 #   undef JITTER_ARGU1
41198 #   undef JITTER_ARGP1
41199 #   undef JITTER_ARGF1
41200 
41201 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41202 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41203 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41204 
41205   }
41206 #ifndef JITTER_REPLICATE
41207  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n1/fR*-no-fast-branches, _Acheck_min_marity__n1__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41208 #endif // #ifndef JITTER_REPLICATE
41209 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41210 
41211   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n2/fR*-no-fast-branches, _Acheck_min_marity__n2__fR_A_mno_mfast_mbranches, hot)
41212   {
41213     /* This specialized instruction is a replacement. */
41214 #   undef JITTER_BRANCH_FAST
41215 #   define JITTER_BRANCH_FAST JITTER_BRANCH
41216 #   undef JITTER_BRANCH_FAST_IF_ZERO
41217 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
41218 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41219 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
41220 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41221 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
41222 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41223 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
41224 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41225 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
41226 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41227 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
41228 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41229 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
41230 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41231 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
41232 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41233 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
41234 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41235 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
41236 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41237 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
41238 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41239 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
41240 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41241 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
41242 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41243 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
41244 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41245 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
41246 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41247 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
41248 #   undef JITTER_BRANCH_FAST_IF_AND
41249 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
41250 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41251 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
41252 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41253 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
41254 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41255 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
41256 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41257 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
41258 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41259 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
41260 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41261 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
41262 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41263 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
41264 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41265 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
41266 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41267 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
41268 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41269 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
41270 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41271 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
41272 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41273 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
41274 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41275 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
41276 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41277 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
41278     /* This specialized instruction is non-relocatable.
41279        Its 1-th argument, a literal, is the return address where to jump
41280        at the end, back to relocated code. */
41281 
41282 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       223
41283 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n2/fR*-no-fast-branches
41284 
41285 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n2__fR_A_mno_mfast_mbranches
41286 
41287   /* The residual arity for this instruction does not depend on fast labels. */
41288   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
41289 
41290   /* Define argument-access macros for *check-in-arity/n2/fR*-no-fast-branches . */
41291 #ifdef JITTER_HAVE_PATCH_IN
41292   /* Define argument-access macros assuming that fast branches are enabled. */
41293     /* The 0th argument is a nonresidual literal. */
41294 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
41295 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41296 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41297 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41298 
41299     /* The 1th argument is a residual label. */
41300 #if defined(JITTER_DISPATCH_NO_THREADING)
41301 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41302     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41303 #elif defined (JITTER_REPLICATE)
41304 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41305 #else
41306 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41307 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41308 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41309 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41310 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41311 #   define JITTER_ARGF1 JITTER_ARGP1
41312 
41313 #else
41314   /* Define argument-access macros assuming that fast branches are disabled. */
41315     /* The 0th argument is a nonresidual literal. */
41316 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
41317 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41318 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41319 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41320 #   define JITTER_ARGF0 JITTER_ARGP0
41321 
41322     /* The 1th argument is a residual label. */
41323 #if defined(JITTER_DISPATCH_NO_THREADING)
41324 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41325     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41326 #elif defined (JITTER_REPLICATE)
41327 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41328 #else
41329 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41330 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41331 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41332 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41333 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41334 #   define JITTER_ARGF1 JITTER_ARGP1
41335 
41336 # endif // #ifdef JITTER_HAVE_PATCH_IN
41337 
41338 #ifdef JITTER_REPLICATE
41339     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
41340        it on the stack rather than in read-only memory.  I had to do this to prevent
41341        a GCC 8 snapshot on SH from being too clever. */
41342     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41343     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
41344        in memory, as a 16-bit constant; and since it reads it with a PC-relative
41345        load the relocated part crashes.
41346                  mov.w     .L1667,r0
41347                  mov.l     @(r0,r15),r1
41348                  jmp       @r1
41349        r15 is the stack pointer.  The constant at .L1667 is
41350           .L1667:
41351                  .short    232
41352        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
41353        can't work as an immediate.  Shall I keep these code pointers as a single array?
41354        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
41355        but the problem will be the same. */
41356     /* Jump to non-relocatable code. */
41357     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41358 
41359     /* Here the residual arity is given as zero: it's too late to
41360        skip residuals, since we've already jumped and this code is
41361        unreachable.  The instruction pointer, if any, is advanced
41362        in the non-relocatable code. */
41363     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n2/fR*-no-fast-branches, _Acheck_min_marity__n2__fR_A_mno_mfast_mbranches, 0)
41364 
41365     /* Relocated code will jump to this label in non-relocated code. */
41366   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
41367     JITTER_COMMENT_IN_ASM_("*check-in-arity/n2/fR*-no-fast-branches non-relocatable code");
41368 #endif // #ifdef JITTER_REPLICATE
41369 #if defined (JITTER_PROFILE_SAMPLE)
41370   JITTER_PROFILE_SAMPLE_UPDATE
41371      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41372       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41373   /* Force the compiler not move sample-profiling instrumentation
41374      beyond this point; this way the actual user code is timed.
41375      This is still not perfect, as residuals are materialised before
41376      we arrive here, but should be adequate at least for slow VM
41377      instructions. */
41378   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41379 #endif
41380 #if defined (JITTER_PROFILE_COUNT)
41381   /* Notice that, differently from the code above, this
41382      instrumentation code *can* be reordered freely: as long as a
41383      VM instruction is counted, the count increment can be placed
41384      anyehere.  Let GCC move this code and possibly achieve better
41385      throughput by exploiting instruction-level parallelism and
41386      therefore approximate more closely a non-profiled build. */
41387   JITTER_PROFILE_COUNT_UPDATE
41388      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41389       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41390 #endif
41391 
41392 /* User-specified code, instruction-beginning-c part: beginning. */
41393 
41394 
41395 /* User-specified code, instruction-beginning-c part: end */
41396 
41397 
41398     /* User code for *check-in-arity/n2/fR*-no-fast-branches . */
41399 
41400 #   ifndef JITTERLISP_UNSAFE
41401       /* Here we can assume that the top object is a closure, without checking:
41402          we either already performed a type check, or the compiler decided it
41403          wasn't necessary. */
41404       jitterlisp_object top = JITTER_TOP_MAINSTACK();
41405       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
41406 
41407       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
41408 #   endif // #ifndef JITTERLISP_UNSAFE
41409 
41410     /* End of the user code for *check-in-arity/n2/fR*-no-fast-branches . */
41411 
41412 /* User-specified code, instruction-end-c part: beginning. */
41413 
41414 
41415 /* User-specified code, instruction-end-c part: end */
41416 
41417 #ifdef JITTER_REPLICATE
41418     /* Advance the instruction pointer, if any, to skip residuals;
41419        then jump back to replicated code. */
41420     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
41421     JITTER_SKIP_RESIDUALS_;
41422     goto * _jitter_back_to_replicated_code_pointer;
41423 #endif // #ifdef JITTER_REPLICATE
41424 
41425     /* Undefine the *check-in-arity/n2/fR*-no-fast-branches argument macros so they can't be used
41426        by mistake in the instruction body coming next. */
41427 #   undef JITTER_SLOW_REGISTER_OFFSET0
41428 #   undef JITTER_ARG0
41429 #   undef JITTER_ARGN0
41430 #   undef JITTER_ARGU0
41431 #   undef JITTER_ARGP0
41432 #   undef JITTER_ARGF0
41433 #   undef JITTER_SLOW_REGISTER_OFFSET1
41434 #   undef JITTER_ARG1
41435 #   undef JITTER_ARGN1
41436 #   undef JITTER_ARGU1
41437 #   undef JITTER_ARGP1
41438 #   undef JITTER_ARGF1
41439 
41440 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41441 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41442 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41443 
41444   }
41445 #ifndef JITTER_REPLICATE
41446  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n2/fR*-no-fast-branches, _Acheck_min_marity__n2__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41447 #endif // #ifndef JITTER_REPLICATE
41448 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41449 
41450   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n3/fR*-no-fast-branches, _Acheck_min_marity__n3__fR_A_mno_mfast_mbranches, hot)
41451   {
41452     /* This specialized instruction is a replacement. */
41453 #   undef JITTER_BRANCH_FAST
41454 #   define JITTER_BRANCH_FAST JITTER_BRANCH
41455 #   undef JITTER_BRANCH_FAST_IF_ZERO
41456 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
41457 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41458 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
41459 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41460 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
41461 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41462 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
41463 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41464 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
41465 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41466 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
41467 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41468 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
41469 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41470 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
41471 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41472 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
41473 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41474 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
41475 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41476 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
41477 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41478 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
41479 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41480 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
41481 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41482 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
41483 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41484 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
41485 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41486 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
41487 #   undef JITTER_BRANCH_FAST_IF_AND
41488 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
41489 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41490 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
41491 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41492 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
41493 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41494 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
41495 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41496 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
41497 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41498 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
41499 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41500 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
41501 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41502 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
41503 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41504 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
41505 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41506 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
41507 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41508 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
41509 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41510 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
41511 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41512 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
41513 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41514 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
41515 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41516 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
41517     /* This specialized instruction is non-relocatable.
41518        Its 1-th argument, a literal, is the return address where to jump
41519        at the end, back to relocated code. */
41520 
41521 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       224
41522 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n3/fR*-no-fast-branches
41523 
41524 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n3__fR_A_mno_mfast_mbranches
41525 
41526   /* The residual arity for this instruction does not depend on fast labels. */
41527   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
41528 
41529   /* Define argument-access macros for *check-in-arity/n3/fR*-no-fast-branches . */
41530 #ifdef JITTER_HAVE_PATCH_IN
41531   /* Define argument-access macros assuming that fast branches are enabled. */
41532     /* The 0th argument is a nonresidual literal. */
41533 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
41534 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41535 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41536 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41537 
41538     /* The 1th argument is a residual label. */
41539 #if defined(JITTER_DISPATCH_NO_THREADING)
41540 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41541     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41542 #elif defined (JITTER_REPLICATE)
41543 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41544 #else
41545 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41546 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41547 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41548 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41549 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41550 #   define JITTER_ARGF1 JITTER_ARGP1
41551 
41552 #else
41553   /* Define argument-access macros assuming that fast branches are disabled. */
41554     /* The 0th argument is a nonresidual literal. */
41555 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
41556 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41557 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41558 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41559 #   define JITTER_ARGF0 JITTER_ARGP0
41560 
41561     /* The 1th argument is a residual label. */
41562 #if defined(JITTER_DISPATCH_NO_THREADING)
41563 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41564     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41565 #elif defined (JITTER_REPLICATE)
41566 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41567 #else
41568 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41569 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41570 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41571 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41572 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41573 #   define JITTER_ARGF1 JITTER_ARGP1
41574 
41575 # endif // #ifdef JITTER_HAVE_PATCH_IN
41576 
41577 #ifdef JITTER_REPLICATE
41578     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
41579        it on the stack rather than in read-only memory.  I had to do this to prevent
41580        a GCC 8 snapshot on SH from being too clever. */
41581     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41582     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
41583        in memory, as a 16-bit constant; and since it reads it with a PC-relative
41584        load the relocated part crashes.
41585                  mov.w     .L1667,r0
41586                  mov.l     @(r0,r15),r1
41587                  jmp       @r1
41588        r15 is the stack pointer.  The constant at .L1667 is
41589           .L1667:
41590                  .short    232
41591        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
41592        can't work as an immediate.  Shall I keep these code pointers as a single array?
41593        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
41594        but the problem will be the same. */
41595     /* Jump to non-relocatable code. */
41596     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41597 
41598     /* Here the residual arity is given as zero: it's too late to
41599        skip residuals, since we've already jumped and this code is
41600        unreachable.  The instruction pointer, if any, is advanced
41601        in the non-relocatable code. */
41602     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n3/fR*-no-fast-branches, _Acheck_min_marity__n3__fR_A_mno_mfast_mbranches, 0)
41603 
41604     /* Relocated code will jump to this label in non-relocated code. */
41605   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
41606     JITTER_COMMENT_IN_ASM_("*check-in-arity/n3/fR*-no-fast-branches non-relocatable code");
41607 #endif // #ifdef JITTER_REPLICATE
41608 #if defined (JITTER_PROFILE_SAMPLE)
41609   JITTER_PROFILE_SAMPLE_UPDATE
41610      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41611       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41612   /* Force the compiler not move sample-profiling instrumentation
41613      beyond this point; this way the actual user code is timed.
41614      This is still not perfect, as residuals are materialised before
41615      we arrive here, but should be adequate at least for slow VM
41616      instructions. */
41617   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41618 #endif
41619 #if defined (JITTER_PROFILE_COUNT)
41620   /* Notice that, differently from the code above, this
41621      instrumentation code *can* be reordered freely: as long as a
41622      VM instruction is counted, the count increment can be placed
41623      anyehere.  Let GCC move this code and possibly achieve better
41624      throughput by exploiting instruction-level parallelism and
41625      therefore approximate more closely a non-profiled build. */
41626   JITTER_PROFILE_COUNT_UPDATE
41627      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41628       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41629 #endif
41630 
41631 /* User-specified code, instruction-beginning-c part: beginning. */
41632 
41633 
41634 /* User-specified code, instruction-beginning-c part: end */
41635 
41636 
41637     /* User code for *check-in-arity/n3/fR*-no-fast-branches . */
41638 
41639 #   ifndef JITTERLISP_UNSAFE
41640       /* Here we can assume that the top object is a closure, without checking:
41641          we either already performed a type check, or the compiler decided it
41642          wasn't necessary. */
41643       jitterlisp_object top = JITTER_TOP_MAINSTACK();
41644       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
41645 
41646       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
41647 #   endif // #ifndef JITTERLISP_UNSAFE
41648 
41649     /* End of the user code for *check-in-arity/n3/fR*-no-fast-branches . */
41650 
41651 /* User-specified code, instruction-end-c part: beginning. */
41652 
41653 
41654 /* User-specified code, instruction-end-c part: end */
41655 
41656 #ifdef JITTER_REPLICATE
41657     /* Advance the instruction pointer, if any, to skip residuals;
41658        then jump back to replicated code. */
41659     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
41660     JITTER_SKIP_RESIDUALS_;
41661     goto * _jitter_back_to_replicated_code_pointer;
41662 #endif // #ifdef JITTER_REPLICATE
41663 
41664     /* Undefine the *check-in-arity/n3/fR*-no-fast-branches argument macros so they can't be used
41665        by mistake in the instruction body coming next. */
41666 #   undef JITTER_SLOW_REGISTER_OFFSET0
41667 #   undef JITTER_ARG0
41668 #   undef JITTER_ARGN0
41669 #   undef JITTER_ARGU0
41670 #   undef JITTER_ARGP0
41671 #   undef JITTER_ARGF0
41672 #   undef JITTER_SLOW_REGISTER_OFFSET1
41673 #   undef JITTER_ARG1
41674 #   undef JITTER_ARGN1
41675 #   undef JITTER_ARGU1
41676 #   undef JITTER_ARGP1
41677 #   undef JITTER_ARGF1
41678 
41679 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41680 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41681 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41682 
41683   }
41684 #ifndef JITTER_REPLICATE
41685  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n3/fR*-no-fast-branches, _Acheck_min_marity__n3__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41686 #endif // #ifndef JITTER_REPLICATE
41687 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41688 
41689   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n4/fR*-no-fast-branches, _Acheck_min_marity__n4__fR_A_mno_mfast_mbranches, hot)
41690   {
41691     /* This specialized instruction is a replacement. */
41692 #   undef JITTER_BRANCH_FAST
41693 #   define JITTER_BRANCH_FAST JITTER_BRANCH
41694 #   undef JITTER_BRANCH_FAST_IF_ZERO
41695 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
41696 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41697 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
41698 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41699 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
41700 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41701 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
41702 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41703 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
41704 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41705 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
41706 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41707 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
41708 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41709 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
41710 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41711 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
41712 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41713 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
41714 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41715 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
41716 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41717 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
41718 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41719 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
41720 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41721 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
41722 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41723 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
41724 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41725 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
41726 #   undef JITTER_BRANCH_FAST_IF_AND
41727 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
41728 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41729 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
41730 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41731 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
41732 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41733 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
41734 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41735 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
41736 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41737 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
41738 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41739 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
41740 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41741 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
41742 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41743 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
41744 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41745 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
41746 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41747 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
41748 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41749 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
41750 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41751 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
41752 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41753 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
41754 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41755 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
41756     /* This specialized instruction is non-relocatable.
41757        Its 1-th argument, a literal, is the return address where to jump
41758        at the end, back to relocated code. */
41759 
41760 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       225
41761 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n4/fR*-no-fast-branches
41762 
41763 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n4__fR_A_mno_mfast_mbranches
41764 
41765   /* The residual arity for this instruction does not depend on fast labels. */
41766   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
41767 
41768   /* Define argument-access macros for *check-in-arity/n4/fR*-no-fast-branches . */
41769 #ifdef JITTER_HAVE_PATCH_IN
41770   /* Define argument-access macros assuming that fast branches are enabled. */
41771     /* The 0th argument is a nonresidual literal. */
41772 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
41773 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41774 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41775 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41776 
41777     /* The 1th argument is a residual label. */
41778 #if defined(JITTER_DISPATCH_NO_THREADING)
41779 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41780     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41781 #elif defined (JITTER_REPLICATE)
41782 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41783 #else
41784 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41785 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41786 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41787 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41788 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41789 #   define JITTER_ARGF1 JITTER_ARGP1
41790 
41791 #else
41792   /* Define argument-access macros assuming that fast branches are disabled. */
41793     /* The 0th argument is a nonresidual literal. */
41794 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
41795 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
41796 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
41797 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
41798 #   define JITTER_ARGF0 JITTER_ARGP0
41799 
41800     /* The 1th argument is a residual label. */
41801 #if defined(JITTER_DISPATCH_NO_THREADING)
41802 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
41803     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
41804 #elif defined (JITTER_REPLICATE)
41805 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
41806 #else
41807 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
41808 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
41809 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
41810 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
41811 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
41812 #   define JITTER_ARGF1 JITTER_ARGP1
41813 
41814 # endif // #ifdef JITTER_HAVE_PATCH_IN
41815 
41816 #ifdef JITTER_REPLICATE
41817     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
41818        it on the stack rather than in read-only memory.  I had to do this to prevent
41819        a GCC 8 snapshot on SH from being too clever. */
41820     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41821     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
41822        in memory, as a 16-bit constant; and since it reads it with a PC-relative
41823        load the relocated part crashes.
41824                  mov.w     .L1667,r0
41825                  mov.l     @(r0,r15),r1
41826                  jmp       @r1
41827        r15 is the stack pointer.  The constant at .L1667 is
41828           .L1667:
41829                  .short    232
41830        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
41831        can't work as an immediate.  Shall I keep these code pointers as a single array?
41832        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
41833        but the problem will be the same. */
41834     /* Jump to non-relocatable code. */
41835     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
41836 
41837     /* Here the residual arity is given as zero: it's too late to
41838        skip residuals, since we've already jumped and this code is
41839        unreachable.  The instruction pointer, if any, is advanced
41840        in the non-relocatable code. */
41841     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n4/fR*-no-fast-branches, _Acheck_min_marity__n4__fR_A_mno_mfast_mbranches, 0)
41842 
41843     /* Relocated code will jump to this label in non-relocated code. */
41844   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
41845     JITTER_COMMENT_IN_ASM_("*check-in-arity/n4/fR*-no-fast-branches non-relocatable code");
41846 #endif // #ifdef JITTER_REPLICATE
41847 #if defined (JITTER_PROFILE_SAMPLE)
41848   JITTER_PROFILE_SAMPLE_UPDATE
41849      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41850       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41851   /* Force the compiler not move sample-profiling instrumentation
41852      beyond this point; this way the actual user code is timed.
41853      This is still not perfect, as residuals are materialised before
41854      we arrive here, but should be adequate at least for slow VM
41855      instructions. */
41856   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
41857 #endif
41858 #if defined (JITTER_PROFILE_COUNT)
41859   /* Notice that, differently from the code above, this
41860      instrumentation code *can* be reordered freely: as long as a
41861      VM instruction is counted, the count increment can be placed
41862      anyehere.  Let GCC move this code and possibly achieve better
41863      throughput by exploiting instruction-level parallelism and
41864      therefore approximate more closely a non-profiled build. */
41865   JITTER_PROFILE_COUNT_UPDATE
41866      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
41867       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
41868 #endif
41869 
41870 /* User-specified code, instruction-beginning-c part: beginning. */
41871 
41872 
41873 /* User-specified code, instruction-beginning-c part: end */
41874 
41875 
41876     /* User code for *check-in-arity/n4/fR*-no-fast-branches . */
41877 
41878 #   ifndef JITTERLISP_UNSAFE
41879       /* Here we can assume that the top object is a closure, without checking:
41880          we either already performed a type check, or the compiler decided it
41881          wasn't necessary. */
41882       jitterlisp_object top = JITTER_TOP_MAINSTACK();
41883       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
41884 
41885       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
41886 #   endif // #ifndef JITTERLISP_UNSAFE
41887 
41888     /* End of the user code for *check-in-arity/n4/fR*-no-fast-branches . */
41889 
41890 /* User-specified code, instruction-end-c part: beginning. */
41891 
41892 
41893 /* User-specified code, instruction-end-c part: end */
41894 
41895 #ifdef JITTER_REPLICATE
41896     /* Advance the instruction pointer, if any, to skip residuals;
41897        then jump back to replicated code. */
41898     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
41899     JITTER_SKIP_RESIDUALS_;
41900     goto * _jitter_back_to_replicated_code_pointer;
41901 #endif // #ifdef JITTER_REPLICATE
41902 
41903     /* Undefine the *check-in-arity/n4/fR*-no-fast-branches argument macros so they can't be used
41904        by mistake in the instruction body coming next. */
41905 #   undef JITTER_SLOW_REGISTER_OFFSET0
41906 #   undef JITTER_ARG0
41907 #   undef JITTER_ARGN0
41908 #   undef JITTER_ARGU0
41909 #   undef JITTER_ARGP0
41910 #   undef JITTER_ARGF0
41911 #   undef JITTER_SLOW_REGISTER_OFFSET1
41912 #   undef JITTER_ARG1
41913 #   undef JITTER_ARGN1
41914 #   undef JITTER_ARGU1
41915 #   undef JITTER_ARGP1
41916 #   undef JITTER_ARGF1
41917 
41918 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
41919 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
41920 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
41921 
41922   }
41923 #ifndef JITTER_REPLICATE
41924  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n4/fR*-no-fast-branches, _Acheck_min_marity__n4__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
41925 #endif // #ifndef JITTER_REPLICATE
41926 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
41927 
41928   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n5/fR*-no-fast-branches, _Acheck_min_marity__n5__fR_A_mno_mfast_mbranches, hot)
41929   {
41930     /* This specialized instruction is a replacement. */
41931 #   undef JITTER_BRANCH_FAST
41932 #   define JITTER_BRANCH_FAST JITTER_BRANCH
41933 #   undef JITTER_BRANCH_FAST_IF_ZERO
41934 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
41935 #   undef JITTER_BRANCH_FAST_IF_NONZERO
41936 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
41937 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
41938 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
41939 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
41940 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
41941 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
41942 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
41943 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
41944 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
41945 #   undef JITTER_BRANCH_FAST_IF_EQUAL
41946 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
41947 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
41948 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
41949 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
41950 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
41951 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
41952 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
41953 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
41954 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
41955 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
41956 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
41957 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
41958 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
41959 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
41960 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
41961 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
41962 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
41963 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
41964 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
41965 #   undef JITTER_BRANCH_FAST_IF_AND
41966 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
41967 #   undef JITTER_BRANCH_FAST_IF_NOTAND
41968 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
41969 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
41970 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
41971 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
41972 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
41973 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
41974 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
41975 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
41976 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
41977 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
41978 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
41979 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
41980 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
41981 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
41982 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
41983 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
41984 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
41985 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
41986 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
41987 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
41988 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
41989 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
41990 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
41991 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
41992 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
41993 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
41994 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
41995     /* This specialized instruction is non-relocatable.
41996        Its 1-th argument, a literal, is the return address where to jump
41997        at the end, back to relocated code. */
41998 
41999 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       226
42000 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n5/fR*-no-fast-branches
42001 
42002 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n5__fR_A_mno_mfast_mbranches
42003 
42004   /* The residual arity for this instruction does not depend on fast labels. */
42005   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
42006 
42007   /* Define argument-access macros for *check-in-arity/n5/fR*-no-fast-branches . */
42008 #ifdef JITTER_HAVE_PATCH_IN
42009   /* Define argument-access macros assuming that fast branches are enabled. */
42010     /* The 0th argument is a nonresidual literal. */
42011 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
42012 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42013 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42014 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42015 
42016     /* The 1th argument is a residual label. */
42017 #if defined(JITTER_DISPATCH_NO_THREADING)
42018 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42019     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42020 #elif defined (JITTER_REPLICATE)
42021 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42022 #else
42023 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42024 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42025 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42026 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42027 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42028 #   define JITTER_ARGF1 JITTER_ARGP1
42029 
42030 #else
42031   /* Define argument-access macros assuming that fast branches are disabled. */
42032     /* The 0th argument is a nonresidual literal. */
42033 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
42034 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42035 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42036 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42037 #   define JITTER_ARGF0 JITTER_ARGP0
42038 
42039     /* The 1th argument is a residual label. */
42040 #if defined(JITTER_DISPATCH_NO_THREADING)
42041 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42042     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42043 #elif defined (JITTER_REPLICATE)
42044 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42045 #else
42046 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42047 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42048 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42049 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42050 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42051 #   define JITTER_ARGF1 JITTER_ARGP1
42052 
42053 # endif // #ifdef JITTER_HAVE_PATCH_IN
42054 
42055 #ifdef JITTER_REPLICATE
42056     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
42057        it on the stack rather than in read-only memory.  I had to do this to prevent
42058        a GCC 8 snapshot on SH from being too clever. */
42059     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42060     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
42061        in memory, as a 16-bit constant; and since it reads it with a PC-relative
42062        load the relocated part crashes.
42063                  mov.w     .L1667,r0
42064                  mov.l     @(r0,r15),r1
42065                  jmp       @r1
42066        r15 is the stack pointer.  The constant at .L1667 is
42067           .L1667:
42068                  .short    232
42069        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
42070        can't work as an immediate.  Shall I keep these code pointers as a single array?
42071        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
42072        but the problem will be the same. */
42073     /* Jump to non-relocatable code. */
42074     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42075 
42076     /* Here the residual arity is given as zero: it's too late to
42077        skip residuals, since we've already jumped and this code is
42078        unreachable.  The instruction pointer, if any, is advanced
42079        in the non-relocatable code. */
42080     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n5/fR*-no-fast-branches, _Acheck_min_marity__n5__fR_A_mno_mfast_mbranches, 0)
42081 
42082     /* Relocated code will jump to this label in non-relocated code. */
42083   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
42084     JITTER_COMMENT_IN_ASM_("*check-in-arity/n5/fR*-no-fast-branches non-relocatable code");
42085 #endif // #ifdef JITTER_REPLICATE
42086 #if defined (JITTER_PROFILE_SAMPLE)
42087   JITTER_PROFILE_SAMPLE_UPDATE
42088      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42089       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42090   /* Force the compiler not move sample-profiling instrumentation
42091      beyond this point; this way the actual user code is timed.
42092      This is still not perfect, as residuals are materialised before
42093      we arrive here, but should be adequate at least for slow VM
42094      instructions. */
42095   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42096 #endif
42097 #if defined (JITTER_PROFILE_COUNT)
42098   /* Notice that, differently from the code above, this
42099      instrumentation code *can* be reordered freely: as long as a
42100      VM instruction is counted, the count increment can be placed
42101      anyehere.  Let GCC move this code and possibly achieve better
42102      throughput by exploiting instruction-level parallelism and
42103      therefore approximate more closely a non-profiled build. */
42104   JITTER_PROFILE_COUNT_UPDATE
42105      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42106       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42107 #endif
42108 
42109 /* User-specified code, instruction-beginning-c part: beginning. */
42110 
42111 
42112 /* User-specified code, instruction-beginning-c part: end */
42113 
42114 
42115     /* User code for *check-in-arity/n5/fR*-no-fast-branches . */
42116 
42117 #   ifndef JITTERLISP_UNSAFE
42118       /* Here we can assume that the top object is a closure, without checking:
42119          we either already performed a type check, or the compiler decided it
42120          wasn't necessary. */
42121       jitterlisp_object top = JITTER_TOP_MAINSTACK();
42122       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
42123 
42124       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
42125 #   endif // #ifndef JITTERLISP_UNSAFE
42126 
42127     /* End of the user code for *check-in-arity/n5/fR*-no-fast-branches . */
42128 
42129 /* User-specified code, instruction-end-c part: beginning. */
42130 
42131 
42132 /* User-specified code, instruction-end-c part: end */
42133 
42134 #ifdef JITTER_REPLICATE
42135     /* Advance the instruction pointer, if any, to skip residuals;
42136        then jump back to replicated code. */
42137     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
42138     JITTER_SKIP_RESIDUALS_;
42139     goto * _jitter_back_to_replicated_code_pointer;
42140 #endif // #ifdef JITTER_REPLICATE
42141 
42142     /* Undefine the *check-in-arity/n5/fR*-no-fast-branches argument macros so they can't be used
42143        by mistake in the instruction body coming next. */
42144 #   undef JITTER_SLOW_REGISTER_OFFSET0
42145 #   undef JITTER_ARG0
42146 #   undef JITTER_ARGN0
42147 #   undef JITTER_ARGU0
42148 #   undef JITTER_ARGP0
42149 #   undef JITTER_ARGF0
42150 #   undef JITTER_SLOW_REGISTER_OFFSET1
42151 #   undef JITTER_ARG1
42152 #   undef JITTER_ARGN1
42153 #   undef JITTER_ARGU1
42154 #   undef JITTER_ARGP1
42155 #   undef JITTER_ARGF1
42156 
42157 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42158 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42159 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42160 
42161   }
42162 #ifndef JITTER_REPLICATE
42163  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n5/fR*-no-fast-branches, _Acheck_min_marity__n5__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42164 #endif // #ifndef JITTER_REPLICATE
42165 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42166 
42167   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n6/fR*-no-fast-branches, _Acheck_min_marity__n6__fR_A_mno_mfast_mbranches, hot)
42168   {
42169     /* This specialized instruction is a replacement. */
42170 #   undef JITTER_BRANCH_FAST
42171 #   define JITTER_BRANCH_FAST JITTER_BRANCH
42172 #   undef JITTER_BRANCH_FAST_IF_ZERO
42173 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
42174 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42175 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
42176 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42177 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
42178 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42179 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
42180 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42181 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
42182 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42183 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
42184 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42185 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
42186 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42187 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
42188 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42189 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
42190 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42191 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
42192 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42193 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
42194 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42195 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
42196 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42197 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
42198 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42199 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
42200 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42201 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
42202 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42203 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
42204 #   undef JITTER_BRANCH_FAST_IF_AND
42205 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
42206 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42207 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
42208 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42209 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
42210 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42211 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
42212 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42213 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
42214 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42215 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
42216 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42217 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
42218 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42219 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
42220 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42221 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
42222 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42223 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
42224 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42225 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
42226 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42227 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
42228 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42229 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
42230 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42231 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
42232 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42233 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
42234     /* This specialized instruction is non-relocatable.
42235        Its 1-th argument, a literal, is the return address where to jump
42236        at the end, back to relocated code. */
42237 
42238 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       227
42239 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n6/fR*-no-fast-branches
42240 
42241 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n6__fR_A_mno_mfast_mbranches
42242 
42243   /* The residual arity for this instruction does not depend on fast labels. */
42244   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
42245 
42246   /* Define argument-access macros for *check-in-arity/n6/fR*-no-fast-branches . */
42247 #ifdef JITTER_HAVE_PATCH_IN
42248   /* Define argument-access macros assuming that fast branches are enabled. */
42249     /* The 0th argument is a nonresidual literal. */
42250 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
42251 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42252 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42253 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42254 
42255     /* The 1th argument is a residual label. */
42256 #if defined(JITTER_DISPATCH_NO_THREADING)
42257 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42258     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42259 #elif defined (JITTER_REPLICATE)
42260 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42261 #else
42262 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42263 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42264 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42265 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42266 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42267 #   define JITTER_ARGF1 JITTER_ARGP1
42268 
42269 #else
42270   /* Define argument-access macros assuming that fast branches are disabled. */
42271     /* The 0th argument is a nonresidual literal. */
42272 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
42273 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42274 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42275 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42276 #   define JITTER_ARGF0 JITTER_ARGP0
42277 
42278     /* The 1th argument is a residual label. */
42279 #if defined(JITTER_DISPATCH_NO_THREADING)
42280 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42281     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42282 #elif defined (JITTER_REPLICATE)
42283 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42284 #else
42285 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42286 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42287 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42288 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42289 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42290 #   define JITTER_ARGF1 JITTER_ARGP1
42291 
42292 # endif // #ifdef JITTER_HAVE_PATCH_IN
42293 
42294 #ifdef JITTER_REPLICATE
42295     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
42296        it on the stack rather than in read-only memory.  I had to do this to prevent
42297        a GCC 8 snapshot on SH from being too clever. */
42298     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42299     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
42300        in memory, as a 16-bit constant; and since it reads it with a PC-relative
42301        load the relocated part crashes.
42302                  mov.w     .L1667,r0
42303                  mov.l     @(r0,r15),r1
42304                  jmp       @r1
42305        r15 is the stack pointer.  The constant at .L1667 is
42306           .L1667:
42307                  .short    232
42308        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
42309        can't work as an immediate.  Shall I keep these code pointers as a single array?
42310        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
42311        but the problem will be the same. */
42312     /* Jump to non-relocatable code. */
42313     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42314 
42315     /* Here the residual arity is given as zero: it's too late to
42316        skip residuals, since we've already jumped and this code is
42317        unreachable.  The instruction pointer, if any, is advanced
42318        in the non-relocatable code. */
42319     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n6/fR*-no-fast-branches, _Acheck_min_marity__n6__fR_A_mno_mfast_mbranches, 0)
42320 
42321     /* Relocated code will jump to this label in non-relocated code. */
42322   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
42323     JITTER_COMMENT_IN_ASM_("*check-in-arity/n6/fR*-no-fast-branches non-relocatable code");
42324 #endif // #ifdef JITTER_REPLICATE
42325 #if defined (JITTER_PROFILE_SAMPLE)
42326   JITTER_PROFILE_SAMPLE_UPDATE
42327      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42328       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42329   /* Force the compiler not move sample-profiling instrumentation
42330      beyond this point; this way the actual user code is timed.
42331      This is still not perfect, as residuals are materialised before
42332      we arrive here, but should be adequate at least for slow VM
42333      instructions. */
42334   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42335 #endif
42336 #if defined (JITTER_PROFILE_COUNT)
42337   /* Notice that, differently from the code above, this
42338      instrumentation code *can* be reordered freely: as long as a
42339      VM instruction is counted, the count increment can be placed
42340      anyehere.  Let GCC move this code and possibly achieve better
42341      throughput by exploiting instruction-level parallelism and
42342      therefore approximate more closely a non-profiled build. */
42343   JITTER_PROFILE_COUNT_UPDATE
42344      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42345       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42346 #endif
42347 
42348 /* User-specified code, instruction-beginning-c part: beginning. */
42349 
42350 
42351 /* User-specified code, instruction-beginning-c part: end */
42352 
42353 
42354     /* User code for *check-in-arity/n6/fR*-no-fast-branches . */
42355 
42356 #   ifndef JITTERLISP_UNSAFE
42357       /* Here we can assume that the top object is a closure, without checking:
42358          we either already performed a type check, or the compiler decided it
42359          wasn't necessary. */
42360       jitterlisp_object top = JITTER_TOP_MAINSTACK();
42361       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
42362 
42363       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
42364 #   endif // #ifndef JITTERLISP_UNSAFE
42365 
42366     /* End of the user code for *check-in-arity/n6/fR*-no-fast-branches . */
42367 
42368 /* User-specified code, instruction-end-c part: beginning. */
42369 
42370 
42371 /* User-specified code, instruction-end-c part: end */
42372 
42373 #ifdef JITTER_REPLICATE
42374     /* Advance the instruction pointer, if any, to skip residuals;
42375        then jump back to replicated code. */
42376     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
42377     JITTER_SKIP_RESIDUALS_;
42378     goto * _jitter_back_to_replicated_code_pointer;
42379 #endif // #ifdef JITTER_REPLICATE
42380 
42381     /* Undefine the *check-in-arity/n6/fR*-no-fast-branches argument macros so they can't be used
42382        by mistake in the instruction body coming next. */
42383 #   undef JITTER_SLOW_REGISTER_OFFSET0
42384 #   undef JITTER_ARG0
42385 #   undef JITTER_ARGN0
42386 #   undef JITTER_ARGU0
42387 #   undef JITTER_ARGP0
42388 #   undef JITTER_ARGF0
42389 #   undef JITTER_SLOW_REGISTER_OFFSET1
42390 #   undef JITTER_ARG1
42391 #   undef JITTER_ARGN1
42392 #   undef JITTER_ARGU1
42393 #   undef JITTER_ARGP1
42394 #   undef JITTER_ARGF1
42395 
42396 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42397 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42398 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42399 
42400   }
42401 #ifndef JITTER_REPLICATE
42402  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n6/fR*-no-fast-branches, _Acheck_min_marity__n6__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42403 #endif // #ifndef JITTER_REPLICATE
42404 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42405 
42406   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n7/fR*-no-fast-branches, _Acheck_min_marity__n7__fR_A_mno_mfast_mbranches, hot)
42407   {
42408     /* This specialized instruction is a replacement. */
42409 #   undef JITTER_BRANCH_FAST
42410 #   define JITTER_BRANCH_FAST JITTER_BRANCH
42411 #   undef JITTER_BRANCH_FAST_IF_ZERO
42412 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
42413 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42414 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
42415 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42416 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
42417 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42418 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
42419 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42420 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
42421 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42422 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
42423 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42424 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
42425 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42426 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
42427 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42428 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
42429 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42430 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
42431 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42432 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
42433 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42434 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
42435 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42436 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
42437 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42438 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
42439 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42440 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
42441 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42442 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
42443 #   undef JITTER_BRANCH_FAST_IF_AND
42444 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
42445 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42446 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
42447 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42448 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
42449 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42450 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
42451 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42452 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
42453 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42454 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
42455 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42456 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
42457 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42458 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
42459 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42460 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
42461 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42462 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
42463 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42464 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
42465 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42466 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
42467 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42468 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
42469 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42470 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
42471 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42472 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
42473     /* This specialized instruction is non-relocatable.
42474        Its 1-th argument, a literal, is the return address where to jump
42475        at the end, back to relocated code. */
42476 
42477 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       228
42478 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n7/fR*-no-fast-branches
42479 
42480 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n7__fR_A_mno_mfast_mbranches
42481 
42482   /* The residual arity for this instruction does not depend on fast labels. */
42483   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
42484 
42485   /* Define argument-access macros for *check-in-arity/n7/fR*-no-fast-branches . */
42486 #ifdef JITTER_HAVE_PATCH_IN
42487   /* Define argument-access macros assuming that fast branches are enabled. */
42488     /* The 0th argument is a nonresidual literal. */
42489 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
42490 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42491 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42492 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42493 
42494     /* The 1th argument is a residual label. */
42495 #if defined(JITTER_DISPATCH_NO_THREADING)
42496 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42497     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42498 #elif defined (JITTER_REPLICATE)
42499 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42500 #else
42501 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42502 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42503 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42504 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42505 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42506 #   define JITTER_ARGF1 JITTER_ARGP1
42507 
42508 #else
42509   /* Define argument-access macros assuming that fast branches are disabled. */
42510     /* The 0th argument is a nonresidual literal. */
42511 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
42512 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42513 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42514 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42515 #   define JITTER_ARGF0 JITTER_ARGP0
42516 
42517     /* The 1th argument is a residual label. */
42518 #if defined(JITTER_DISPATCH_NO_THREADING)
42519 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42520     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42521 #elif defined (JITTER_REPLICATE)
42522 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42523 #else
42524 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42525 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42526 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42527 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42528 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42529 #   define JITTER_ARGF1 JITTER_ARGP1
42530 
42531 # endif // #ifdef JITTER_HAVE_PATCH_IN
42532 
42533 #ifdef JITTER_REPLICATE
42534     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
42535        it on the stack rather than in read-only memory.  I had to do this to prevent
42536        a GCC 8 snapshot on SH from being too clever. */
42537     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42538     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
42539        in memory, as a 16-bit constant; and since it reads it with a PC-relative
42540        load the relocated part crashes.
42541                  mov.w     .L1667,r0
42542                  mov.l     @(r0,r15),r1
42543                  jmp       @r1
42544        r15 is the stack pointer.  The constant at .L1667 is
42545           .L1667:
42546                  .short    232
42547        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
42548        can't work as an immediate.  Shall I keep these code pointers as a single array?
42549        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
42550        but the problem will be the same. */
42551     /* Jump to non-relocatable code. */
42552     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42553 
42554     /* Here the residual arity is given as zero: it's too late to
42555        skip residuals, since we've already jumped and this code is
42556        unreachable.  The instruction pointer, if any, is advanced
42557        in the non-relocatable code. */
42558     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n7/fR*-no-fast-branches, _Acheck_min_marity__n7__fR_A_mno_mfast_mbranches, 0)
42559 
42560     /* Relocated code will jump to this label in non-relocated code. */
42561   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
42562     JITTER_COMMENT_IN_ASM_("*check-in-arity/n7/fR*-no-fast-branches non-relocatable code");
42563 #endif // #ifdef JITTER_REPLICATE
42564 #if defined (JITTER_PROFILE_SAMPLE)
42565   JITTER_PROFILE_SAMPLE_UPDATE
42566      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42567       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42568   /* Force the compiler not move sample-profiling instrumentation
42569      beyond this point; this way the actual user code is timed.
42570      This is still not perfect, as residuals are materialised before
42571      we arrive here, but should be adequate at least for slow VM
42572      instructions. */
42573   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42574 #endif
42575 #if defined (JITTER_PROFILE_COUNT)
42576   /* Notice that, differently from the code above, this
42577      instrumentation code *can* be reordered freely: as long as a
42578      VM instruction is counted, the count increment can be placed
42579      anyehere.  Let GCC move this code and possibly achieve better
42580      throughput by exploiting instruction-level parallelism and
42581      therefore approximate more closely a non-profiled build. */
42582   JITTER_PROFILE_COUNT_UPDATE
42583      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42584       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42585 #endif
42586 
42587 /* User-specified code, instruction-beginning-c part: beginning. */
42588 
42589 
42590 /* User-specified code, instruction-beginning-c part: end */
42591 
42592 
42593     /* User code for *check-in-arity/n7/fR*-no-fast-branches . */
42594 
42595 #   ifndef JITTERLISP_UNSAFE
42596       /* Here we can assume that the top object is a closure, without checking:
42597          we either already performed a type check, or the compiler decided it
42598          wasn't necessary. */
42599       jitterlisp_object top = JITTER_TOP_MAINSTACK();
42600       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
42601 
42602       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
42603 #   endif // #ifndef JITTERLISP_UNSAFE
42604 
42605     /* End of the user code for *check-in-arity/n7/fR*-no-fast-branches . */
42606 
42607 /* User-specified code, instruction-end-c part: beginning. */
42608 
42609 
42610 /* User-specified code, instruction-end-c part: end */
42611 
42612 #ifdef JITTER_REPLICATE
42613     /* Advance the instruction pointer, if any, to skip residuals;
42614        then jump back to replicated code. */
42615     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
42616     JITTER_SKIP_RESIDUALS_;
42617     goto * _jitter_back_to_replicated_code_pointer;
42618 #endif // #ifdef JITTER_REPLICATE
42619 
42620     /* Undefine the *check-in-arity/n7/fR*-no-fast-branches argument macros so they can't be used
42621        by mistake in the instruction body coming next. */
42622 #   undef JITTER_SLOW_REGISTER_OFFSET0
42623 #   undef JITTER_ARG0
42624 #   undef JITTER_ARGN0
42625 #   undef JITTER_ARGU0
42626 #   undef JITTER_ARGP0
42627 #   undef JITTER_ARGF0
42628 #   undef JITTER_SLOW_REGISTER_OFFSET1
42629 #   undef JITTER_ARG1
42630 #   undef JITTER_ARGN1
42631 #   undef JITTER_ARGU1
42632 #   undef JITTER_ARGP1
42633 #   undef JITTER_ARGF1
42634 
42635 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42636 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42637 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42638 
42639   }
42640 #ifndef JITTER_REPLICATE
42641  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n7/fR*-no-fast-branches, _Acheck_min_marity__n7__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42642 #endif // #ifndef JITTER_REPLICATE
42643 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42644 
42645   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n8/fR*-no-fast-branches, _Acheck_min_marity__n8__fR_A_mno_mfast_mbranches, hot)
42646   {
42647     /* This specialized instruction is a replacement. */
42648 #   undef JITTER_BRANCH_FAST
42649 #   define JITTER_BRANCH_FAST JITTER_BRANCH
42650 #   undef JITTER_BRANCH_FAST_IF_ZERO
42651 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
42652 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42653 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
42654 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42655 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
42656 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42657 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
42658 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42659 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
42660 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42661 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
42662 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42663 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
42664 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42665 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
42666 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42667 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
42668 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42669 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
42670 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42671 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
42672 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42673 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
42674 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42675 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
42676 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42677 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
42678 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42679 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
42680 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42681 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
42682 #   undef JITTER_BRANCH_FAST_IF_AND
42683 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
42684 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42685 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
42686 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42687 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
42688 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42689 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
42690 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42691 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
42692 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42693 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
42694 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42695 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
42696 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42697 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
42698 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42699 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
42700 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42701 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
42702 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42703 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
42704 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42705 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
42706 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42707 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
42708 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42709 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
42710 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42711 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
42712     /* This specialized instruction is non-relocatable.
42713        Its 1-th argument, a literal, is the return address where to jump
42714        at the end, back to relocated code. */
42715 
42716 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       229
42717 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n8/fR*-no-fast-branches
42718 
42719 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n8__fR_A_mno_mfast_mbranches
42720 
42721   /* The residual arity for this instruction does not depend on fast labels. */
42722   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
42723 
42724   /* Define argument-access macros for *check-in-arity/n8/fR*-no-fast-branches . */
42725 #ifdef JITTER_HAVE_PATCH_IN
42726   /* Define argument-access macros assuming that fast branches are enabled. */
42727     /* The 0th argument is a nonresidual literal. */
42728 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
42729 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42730 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42731 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42732 
42733     /* The 1th argument is a residual label. */
42734 #if defined(JITTER_DISPATCH_NO_THREADING)
42735 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42736     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42737 #elif defined (JITTER_REPLICATE)
42738 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42739 #else
42740 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42741 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42742 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42743 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42744 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42745 #   define JITTER_ARGF1 JITTER_ARGP1
42746 
42747 #else
42748   /* Define argument-access macros assuming that fast branches are disabled. */
42749     /* The 0th argument is a nonresidual literal. */
42750 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
42751 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42752 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42753 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42754 #   define JITTER_ARGF0 JITTER_ARGP0
42755 
42756     /* The 1th argument is a residual label. */
42757 #if defined(JITTER_DISPATCH_NO_THREADING)
42758 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42759     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42760 #elif defined (JITTER_REPLICATE)
42761 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42762 #else
42763 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42764 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42765 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42766 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42767 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42768 #   define JITTER_ARGF1 JITTER_ARGP1
42769 
42770 # endif // #ifdef JITTER_HAVE_PATCH_IN
42771 
42772 #ifdef JITTER_REPLICATE
42773     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
42774        it on the stack rather than in read-only memory.  I had to do this to prevent
42775        a GCC 8 snapshot on SH from being too clever. */
42776     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42777     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
42778        in memory, as a 16-bit constant; and since it reads it with a PC-relative
42779        load the relocated part crashes.
42780                  mov.w     .L1667,r0
42781                  mov.l     @(r0,r15),r1
42782                  jmp       @r1
42783        r15 is the stack pointer.  The constant at .L1667 is
42784           .L1667:
42785                  .short    232
42786        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
42787        can't work as an immediate.  Shall I keep these code pointers as a single array?
42788        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
42789        but the problem will be the same. */
42790     /* Jump to non-relocatable code. */
42791     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
42792 
42793     /* Here the residual arity is given as zero: it's too late to
42794        skip residuals, since we've already jumped and this code is
42795        unreachable.  The instruction pointer, if any, is advanced
42796        in the non-relocatable code. */
42797     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n8/fR*-no-fast-branches, _Acheck_min_marity__n8__fR_A_mno_mfast_mbranches, 0)
42798 
42799     /* Relocated code will jump to this label in non-relocated code. */
42800   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
42801     JITTER_COMMENT_IN_ASM_("*check-in-arity/n8/fR*-no-fast-branches non-relocatable code");
42802 #endif // #ifdef JITTER_REPLICATE
42803 #if defined (JITTER_PROFILE_SAMPLE)
42804   JITTER_PROFILE_SAMPLE_UPDATE
42805      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42806       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42807   /* Force the compiler not move sample-profiling instrumentation
42808      beyond this point; this way the actual user code is timed.
42809      This is still not perfect, as residuals are materialised before
42810      we arrive here, but should be adequate at least for slow VM
42811      instructions. */
42812   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
42813 #endif
42814 #if defined (JITTER_PROFILE_COUNT)
42815   /* Notice that, differently from the code above, this
42816      instrumentation code *can* be reordered freely: as long as a
42817      VM instruction is counted, the count increment can be placed
42818      anyehere.  Let GCC move this code and possibly achieve better
42819      throughput by exploiting instruction-level parallelism and
42820      therefore approximate more closely a non-profiled build. */
42821   JITTER_PROFILE_COUNT_UPDATE
42822      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
42823       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
42824 #endif
42825 
42826 /* User-specified code, instruction-beginning-c part: beginning. */
42827 
42828 
42829 /* User-specified code, instruction-beginning-c part: end */
42830 
42831 
42832     /* User code for *check-in-arity/n8/fR*-no-fast-branches . */
42833 
42834 #   ifndef JITTERLISP_UNSAFE
42835       /* Here we can assume that the top object is a closure, without checking:
42836          we either already performed a type check, or the compiler decided it
42837          wasn't necessary. */
42838       jitterlisp_object top = JITTER_TOP_MAINSTACK();
42839       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
42840 
42841       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
42842 #   endif // #ifndef JITTERLISP_UNSAFE
42843 
42844     /* End of the user code for *check-in-arity/n8/fR*-no-fast-branches . */
42845 
42846 /* User-specified code, instruction-end-c part: beginning. */
42847 
42848 
42849 /* User-specified code, instruction-end-c part: end */
42850 
42851 #ifdef JITTER_REPLICATE
42852     /* Advance the instruction pointer, if any, to skip residuals;
42853        then jump back to replicated code. */
42854     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
42855     JITTER_SKIP_RESIDUALS_;
42856     goto * _jitter_back_to_replicated_code_pointer;
42857 #endif // #ifdef JITTER_REPLICATE
42858 
42859     /* Undefine the *check-in-arity/n8/fR*-no-fast-branches argument macros so they can't be used
42860        by mistake in the instruction body coming next. */
42861 #   undef JITTER_SLOW_REGISTER_OFFSET0
42862 #   undef JITTER_ARG0
42863 #   undef JITTER_ARGN0
42864 #   undef JITTER_ARGU0
42865 #   undef JITTER_ARGP0
42866 #   undef JITTER_ARGF0
42867 #   undef JITTER_SLOW_REGISTER_OFFSET1
42868 #   undef JITTER_ARG1
42869 #   undef JITTER_ARGN1
42870 #   undef JITTER_ARGU1
42871 #   undef JITTER_ARGP1
42872 #   undef JITTER_ARGF1
42873 
42874 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
42875 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
42876 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
42877 
42878   }
42879 #ifndef JITTER_REPLICATE
42880  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n8/fR*-no-fast-branches, _Acheck_min_marity__n8__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
42881 #endif // #ifndef JITTER_REPLICATE
42882 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
42883 
42884   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n9/fR*-no-fast-branches, _Acheck_min_marity__n9__fR_A_mno_mfast_mbranches, hot)
42885   {
42886     /* This specialized instruction is a replacement. */
42887 #   undef JITTER_BRANCH_FAST
42888 #   define JITTER_BRANCH_FAST JITTER_BRANCH
42889 #   undef JITTER_BRANCH_FAST_IF_ZERO
42890 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
42891 #   undef JITTER_BRANCH_FAST_IF_NONZERO
42892 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
42893 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
42894 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
42895 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
42896 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
42897 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
42898 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
42899 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
42900 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
42901 #   undef JITTER_BRANCH_FAST_IF_EQUAL
42902 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
42903 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
42904 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
42905 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
42906 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
42907 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
42908 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
42909 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
42910 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
42911 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
42912 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
42913 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
42914 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
42915 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
42916 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
42917 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
42918 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
42919 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
42920 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
42921 #   undef JITTER_BRANCH_FAST_IF_AND
42922 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
42923 #   undef JITTER_BRANCH_FAST_IF_NOTAND
42924 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
42925 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
42926 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
42927 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
42928 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
42929 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
42930 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
42931 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
42932 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
42933 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
42934 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
42935 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
42936 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
42937 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
42938 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
42939 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
42940 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
42941 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
42942 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
42943 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
42944 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
42945 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
42946 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
42947 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
42948 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
42949 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
42950 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
42951     /* This specialized instruction is non-relocatable.
42952        Its 1-th argument, a literal, is the return address where to jump
42953        at the end, back to relocated code. */
42954 
42955 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       230
42956 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n9/fR*-no-fast-branches
42957 
42958 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n9__fR_A_mno_mfast_mbranches
42959 
42960   /* The residual arity for this instruction does not depend on fast labels. */
42961   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
42962 
42963   /* Define argument-access macros for *check-in-arity/n9/fR*-no-fast-branches . */
42964 #ifdef JITTER_HAVE_PATCH_IN
42965   /* Define argument-access macros assuming that fast branches are enabled. */
42966     /* The 0th argument is a nonresidual literal. */
42967 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
42968 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42969 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42970 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42971 
42972     /* The 1th argument is a residual label. */
42973 #if defined(JITTER_DISPATCH_NO_THREADING)
42974 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42975     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42976 #elif defined (JITTER_REPLICATE)
42977 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
42978 #else
42979 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
42980 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
42981 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
42982 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
42983 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
42984 #   define JITTER_ARGF1 JITTER_ARGP1
42985 
42986 #else
42987   /* Define argument-access macros assuming that fast branches are disabled. */
42988     /* The 0th argument is a nonresidual literal. */
42989 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
42990 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
42991 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
42992 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
42993 #   define JITTER_ARGF0 JITTER_ARGP0
42994 
42995     /* The 1th argument is a residual label. */
42996 #if defined(JITTER_DISPATCH_NO_THREADING)
42997 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
42998     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
42999 #elif defined (JITTER_REPLICATE)
43000 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
43001 #else
43002 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43003 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43004 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43005 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43006 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43007 #   define JITTER_ARGF1 JITTER_ARGP1
43008 
43009 # endif // #ifdef JITTER_HAVE_PATCH_IN
43010 
43011 #ifdef JITTER_REPLICATE
43012     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
43013        it on the stack rather than in read-only memory.  I had to do this to prevent
43014        a GCC 8 snapshot on SH from being too clever. */
43015     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43016     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
43017        in memory, as a 16-bit constant; and since it reads it with a PC-relative
43018        load the relocated part crashes.
43019                  mov.w     .L1667,r0
43020                  mov.l     @(r0,r15),r1
43021                  jmp       @r1
43022        r15 is the stack pointer.  The constant at .L1667 is
43023           .L1667:
43024                  .short    232
43025        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
43026        can't work as an immediate.  Shall I keep these code pointers as a single array?
43027        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
43028        but the problem will be the same. */
43029     /* Jump to non-relocatable code. */
43030     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43031 
43032     /* Here the residual arity is given as zero: it's too late to
43033        skip residuals, since we've already jumped and this code is
43034        unreachable.  The instruction pointer, if any, is advanced
43035        in the non-relocatable code. */
43036     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n9/fR*-no-fast-branches, _Acheck_min_marity__n9__fR_A_mno_mfast_mbranches, 0)
43037 
43038     /* Relocated code will jump to this label in non-relocated code. */
43039   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
43040     JITTER_COMMENT_IN_ASM_("*check-in-arity/n9/fR*-no-fast-branches non-relocatable code");
43041 #endif // #ifdef JITTER_REPLICATE
43042 #if defined (JITTER_PROFILE_SAMPLE)
43043   JITTER_PROFILE_SAMPLE_UPDATE
43044      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43045       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43046   /* Force the compiler not move sample-profiling instrumentation
43047      beyond this point; this way the actual user code is timed.
43048      This is still not perfect, as residuals are materialised before
43049      we arrive here, but should be adequate at least for slow VM
43050      instructions. */
43051   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43052 #endif
43053 #if defined (JITTER_PROFILE_COUNT)
43054   /* Notice that, differently from the code above, this
43055      instrumentation code *can* be reordered freely: as long as a
43056      VM instruction is counted, the count increment can be placed
43057      anyehere.  Let GCC move this code and possibly achieve better
43058      throughput by exploiting instruction-level parallelism and
43059      therefore approximate more closely a non-profiled build. */
43060   JITTER_PROFILE_COUNT_UPDATE
43061      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43062       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43063 #endif
43064 
43065 /* User-specified code, instruction-beginning-c part: beginning. */
43066 
43067 
43068 /* User-specified code, instruction-beginning-c part: end */
43069 
43070 
43071     /* User code for *check-in-arity/n9/fR*-no-fast-branches . */
43072 
43073 #   ifndef JITTERLISP_UNSAFE
43074       /* Here we can assume that the top object is a closure, without checking:
43075          we either already performed a type check, or the compiler decided it
43076          wasn't necessary. */
43077       jitterlisp_object top = JITTER_TOP_MAINSTACK();
43078       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
43079 
43080       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
43081 #   endif // #ifndef JITTERLISP_UNSAFE
43082 
43083     /* End of the user code for *check-in-arity/n9/fR*-no-fast-branches . */
43084 
43085 /* User-specified code, instruction-end-c part: beginning. */
43086 
43087 
43088 /* User-specified code, instruction-end-c part: end */
43089 
43090 #ifdef JITTER_REPLICATE
43091     /* Advance the instruction pointer, if any, to skip residuals;
43092        then jump back to replicated code. */
43093     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
43094     JITTER_SKIP_RESIDUALS_;
43095     goto * _jitter_back_to_replicated_code_pointer;
43096 #endif // #ifdef JITTER_REPLICATE
43097 
43098     /* Undefine the *check-in-arity/n9/fR*-no-fast-branches argument macros so they can't be used
43099        by mistake in the instruction body coming next. */
43100 #   undef JITTER_SLOW_REGISTER_OFFSET0
43101 #   undef JITTER_ARG0
43102 #   undef JITTER_ARGN0
43103 #   undef JITTER_ARGU0
43104 #   undef JITTER_ARGP0
43105 #   undef JITTER_ARGF0
43106 #   undef JITTER_SLOW_REGISTER_OFFSET1
43107 #   undef JITTER_ARG1
43108 #   undef JITTER_ARGN1
43109 #   undef JITTER_ARGU1
43110 #   undef JITTER_ARGP1
43111 #   undef JITTER_ARGF1
43112 
43113 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43114 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43115 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43116 
43117   }
43118 #ifndef JITTER_REPLICATE
43119  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n9/fR*-no-fast-branches, _Acheck_min_marity__n9__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43120 #endif // #ifndef JITTER_REPLICATE
43121 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43122 
43123   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/n10/fR*-no-fast-branches, _Acheck_min_marity__n10__fR_A_mno_mfast_mbranches, hot)
43124   {
43125     /* This specialized instruction is a replacement. */
43126 #   undef JITTER_BRANCH_FAST
43127 #   define JITTER_BRANCH_FAST JITTER_BRANCH
43128 #   undef JITTER_BRANCH_FAST_IF_ZERO
43129 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
43130 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43131 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
43132 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43133 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
43134 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43135 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
43136 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43137 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
43138 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43139 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
43140 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43141 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
43142 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43143 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
43144 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43145 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
43146 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43147 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
43148 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43149 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
43150 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43151 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
43152 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43153 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
43154 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43155 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
43156 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43157 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
43158 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43159 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
43160 #   undef JITTER_BRANCH_FAST_IF_AND
43161 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
43162 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43163 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
43164 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43165 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
43166 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43167 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
43168 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43169 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
43170 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43171 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
43172 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43173 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
43174 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43175 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
43176 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43177 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
43178 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43179 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
43180 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43181 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
43182 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43183 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
43184 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43185 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
43186 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43187 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
43188 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43189 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
43190     /* This specialized instruction is non-relocatable.
43191        Its 1-th argument, a literal, is the return address where to jump
43192        at the end, back to relocated code. */
43193 
43194 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       231
43195 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/n10/fR*-no-fast-branches
43196 
43197 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__n10__fR_A_mno_mfast_mbranches
43198 
43199   /* The residual arity for this instruction does not depend on fast labels. */
43200   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
43201 
43202   /* Define argument-access macros for *check-in-arity/n10/fR*-no-fast-branches . */
43203 #ifdef JITTER_HAVE_PATCH_IN
43204   /* Define argument-access macros assuming that fast branches are enabled. */
43205     /* The 0th argument is a nonresidual literal. */
43206 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
43207 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43208 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43209 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43210 
43211     /* The 1th argument is a residual label. */
43212 #if defined(JITTER_DISPATCH_NO_THREADING)
43213 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
43214     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43215 #elif defined (JITTER_REPLICATE)
43216 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
43217 #else
43218 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43219 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43220 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43221 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43222 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43223 #   define JITTER_ARGF1 JITTER_ARGP1
43224 
43225 #else
43226   /* Define argument-access macros assuming that fast branches are disabled. */
43227     /* The 0th argument is a nonresidual literal. */
43228 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
43229 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43230 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43231 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43232 #   define JITTER_ARGF0 JITTER_ARGP0
43233 
43234     /* The 1th argument is a residual label. */
43235 #if defined(JITTER_DISPATCH_NO_THREADING)
43236 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
43237     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43238 #elif defined (JITTER_REPLICATE)
43239 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
43240 #else
43241 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43242 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43243 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43244 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43245 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43246 #   define JITTER_ARGF1 JITTER_ARGP1
43247 
43248 # endif // #ifdef JITTER_HAVE_PATCH_IN
43249 
43250 #ifdef JITTER_REPLICATE
43251     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
43252        it on the stack rather than in read-only memory.  I had to do this to prevent
43253        a GCC 8 snapshot on SH from being too clever. */
43254     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43255     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
43256        in memory, as a 16-bit constant; and since it reads it with a PC-relative
43257        load the relocated part crashes.
43258                  mov.w     .L1667,r0
43259                  mov.l     @(r0,r15),r1
43260                  jmp       @r1
43261        r15 is the stack pointer.  The constant at .L1667 is
43262           .L1667:
43263                  .short    232
43264        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
43265        can't work as an immediate.  Shall I keep these code pointers as a single array?
43266        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
43267        but the problem will be the same. */
43268     /* Jump to non-relocatable code. */
43269     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43270 
43271     /* Here the residual arity is given as zero: it's too late to
43272        skip residuals, since we've already jumped and this code is
43273        unreachable.  The instruction pointer, if any, is advanced
43274        in the non-relocatable code. */
43275     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n10/fR*-no-fast-branches, _Acheck_min_marity__n10__fR_A_mno_mfast_mbranches, 0)
43276 
43277     /* Relocated code will jump to this label in non-relocated code. */
43278   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
43279     JITTER_COMMENT_IN_ASM_("*check-in-arity/n10/fR*-no-fast-branches non-relocatable code");
43280 #endif // #ifdef JITTER_REPLICATE
43281 #if defined (JITTER_PROFILE_SAMPLE)
43282   JITTER_PROFILE_SAMPLE_UPDATE
43283      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43284       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43285   /* Force the compiler not move sample-profiling instrumentation
43286      beyond this point; this way the actual user code is timed.
43287      This is still not perfect, as residuals are materialised before
43288      we arrive here, but should be adequate at least for slow VM
43289      instructions. */
43290   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43291 #endif
43292 #if defined (JITTER_PROFILE_COUNT)
43293   /* Notice that, differently from the code above, this
43294      instrumentation code *can* be reordered freely: as long as a
43295      VM instruction is counted, the count increment can be placed
43296      anyehere.  Let GCC move this code and possibly achieve better
43297      throughput by exploiting instruction-level parallelism and
43298      therefore approximate more closely a non-profiled build. */
43299   JITTER_PROFILE_COUNT_UPDATE
43300      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43301       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43302 #endif
43303 
43304 /* User-specified code, instruction-beginning-c part: beginning. */
43305 
43306 
43307 /* User-specified code, instruction-beginning-c part: end */
43308 
43309 
43310     /* User code for *check-in-arity/n10/fR*-no-fast-branches . */
43311 
43312 #   ifndef JITTERLISP_UNSAFE
43313       /* Here we can assume that the top object is a closure, without checking:
43314          we either already performed a type check, or the compiler decided it
43315          wasn't necessary. */
43316       jitterlisp_object top = JITTER_TOP_MAINSTACK();
43317       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
43318 
43319       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
43320 #   endif // #ifndef JITTERLISP_UNSAFE
43321 
43322     /* End of the user code for *check-in-arity/n10/fR*-no-fast-branches . */
43323 
43324 /* User-specified code, instruction-end-c part: beginning. */
43325 
43326 
43327 /* User-specified code, instruction-end-c part: end */
43328 
43329 #ifdef JITTER_REPLICATE
43330     /* Advance the instruction pointer, if any, to skip residuals;
43331        then jump back to replicated code. */
43332     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
43333     JITTER_SKIP_RESIDUALS_;
43334     goto * _jitter_back_to_replicated_code_pointer;
43335 #endif // #ifdef JITTER_REPLICATE
43336 
43337     /* Undefine the *check-in-arity/n10/fR*-no-fast-branches argument macros so they can't be used
43338        by mistake in the instruction body coming next. */
43339 #   undef JITTER_SLOW_REGISTER_OFFSET0
43340 #   undef JITTER_ARG0
43341 #   undef JITTER_ARGN0
43342 #   undef JITTER_ARGU0
43343 #   undef JITTER_ARGP0
43344 #   undef JITTER_ARGF0
43345 #   undef JITTER_SLOW_REGISTER_OFFSET1
43346 #   undef JITTER_ARG1
43347 #   undef JITTER_ARGN1
43348 #   undef JITTER_ARGU1
43349 #   undef JITTER_ARGP1
43350 #   undef JITTER_ARGF1
43351 
43352 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43353 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43354 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43355 
43356   }
43357 #ifndef JITTER_REPLICATE
43358  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/n10/fR*-no-fast-branches, _Acheck_min_marity__n10__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43359 #endif // #ifndef JITTER_REPLICATE
43360 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43361 
43362   JITTER_INSTRUCTION_PROLOG_(*check-in-arity/nR/fR*-no-fast-branches, _Acheck_min_marity__nR__fR_A_mno_mfast_mbranches, cold)
43363   {
43364     /* This specialized instruction is a replacement. */
43365 #   undef JITTER_BRANCH_FAST
43366 #   define JITTER_BRANCH_FAST JITTER_BRANCH
43367 #   undef JITTER_BRANCH_FAST_IF_ZERO
43368 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
43369 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43370 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
43371 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43372 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
43373 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43374 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
43375 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43376 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
43377 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43378 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
43379 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43380 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
43381 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43382 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
43383 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43384 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
43385 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43386 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
43387 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43388 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
43389 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43390 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
43391 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43392 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
43393 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43394 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
43395 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43396 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
43397 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43398 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
43399 #   undef JITTER_BRANCH_FAST_IF_AND
43400 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
43401 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43402 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
43403 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43404 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
43405 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43406 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
43407 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43408 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
43409 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43410 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
43411 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43412 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
43413 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43414 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
43415 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43416 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
43417 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43418 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
43419 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43420 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
43421 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43422 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
43423 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43424 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
43425 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43426 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
43427 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43428 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
43429     /* This specialized instruction is non-relocatable.
43430        Its 1-th argument, a literal, is the return address where to jump
43431        at the end, back to relocated code. */
43432 
43433 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       232
43434 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity/nR/fR*-no-fast-branches
43435 
43436 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity__nR__fR_A_mno_mfast_mbranches
43437 
43438   /* The residual arity for this instruction does not depend on fast labels. */
43439   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
43440 
43441   /* Define argument-access macros for *check-in-arity/nR/fR*-no-fast-branches . */
43442 #ifdef JITTER_HAVE_PATCH_IN
43443   /* Define argument-access macros assuming that fast branches are enabled. */
43444     /* The 0th argument is a residual literal. */
43445 #if defined(JITTER_DISPATCH_NO_THREADING)
43446 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
43447     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43448 #elif defined (JITTER_REPLICATE)
43449 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
43450 #else
43451 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
43452 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43453 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43454 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43455 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43456 
43457     /* The 1th argument is a residual label. */
43458 #if defined(JITTER_DISPATCH_NO_THREADING)
43459 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
43460     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
43461 #elif defined (JITTER_REPLICATE)
43462 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43463 #else
43464 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
43465 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43466 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43467 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43468 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43469 #   define JITTER_ARGF1 JITTER_ARGP1
43470 
43471 #else
43472   /* Define argument-access macros assuming that fast branches are disabled. */
43473     /* The 0th argument is a residual literal. */
43474 #if defined(JITTER_DISPATCH_NO_THREADING)
43475 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
43476     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43477 #elif defined (JITTER_REPLICATE)
43478 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
43479 #else
43480 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
43481 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43482 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43483 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43484 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43485 #   define JITTER_ARGF0 JITTER_ARGP0
43486 
43487     /* The 1th argument is a residual label. */
43488 #if defined(JITTER_DISPATCH_NO_THREADING)
43489 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
43490     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
43491 #elif defined (JITTER_REPLICATE)
43492 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43493 #else
43494 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
43495 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43496 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43497 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43498 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43499 #   define JITTER_ARGF1 JITTER_ARGP1
43500 
43501 # endif // #ifdef JITTER_HAVE_PATCH_IN
43502 
43503 #ifdef JITTER_REPLICATE
43504     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
43505        it on the stack rather than in read-only memory.  I had to do this to prevent
43506        a GCC 8 snapshot on SH from being too clever. */
43507     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43508     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
43509        in memory, as a 16-bit constant; and since it reads it with a PC-relative
43510        load the relocated part crashes.
43511                  mov.w     .L1667,r0
43512                  mov.l     @(r0,r15),r1
43513                  jmp       @r1
43514        r15 is the stack pointer.  The constant at .L1667 is
43515           .L1667:
43516                  .short    232
43517        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
43518        can't work as an immediate.  Shall I keep these code pointers as a single array?
43519        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
43520        but the problem will be the same. */
43521     /* Jump to non-relocatable code. */
43522     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43523 
43524     /* Here the residual arity is given as zero: it's too late to
43525        skip residuals, since we've already jumped and this code is
43526        unreachable.  The instruction pointer, if any, is advanced
43527        in the non-relocatable code. */
43528     JITTER_INSTRUCTION_EPILOG_(*check-in-arity/nR/fR*-no-fast-branches, _Acheck_min_marity__nR__fR_A_mno_mfast_mbranches, 0)
43529 
43530     /* Relocated code will jump to this label in non-relocated code. */
43531   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
43532     JITTER_COMMENT_IN_ASM_("*check-in-arity/nR/fR*-no-fast-branches non-relocatable code");
43533 #endif // #ifdef JITTER_REPLICATE
43534 #if defined (JITTER_PROFILE_SAMPLE)
43535   JITTER_PROFILE_SAMPLE_UPDATE
43536      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43537       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43538   /* Force the compiler not move sample-profiling instrumentation
43539      beyond this point; this way the actual user code is timed.
43540      This is still not perfect, as residuals are materialised before
43541      we arrive here, but should be adequate at least for slow VM
43542      instructions. */
43543   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43544 #endif
43545 #if defined (JITTER_PROFILE_COUNT)
43546   /* Notice that, differently from the code above, this
43547      instrumentation code *can* be reordered freely: as long as a
43548      VM instruction is counted, the count increment can be placed
43549      anyehere.  Let GCC move this code and possibly achieve better
43550      throughput by exploiting instruction-level parallelism and
43551      therefore approximate more closely a non-profiled build. */
43552   JITTER_PROFILE_COUNT_UPDATE
43553      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43554       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43555 #endif
43556 
43557 /* User-specified code, instruction-beginning-c part: beginning. */
43558 
43559 
43560 /* User-specified code, instruction-beginning-c part: end */
43561 
43562 
43563     /* User code for *check-in-arity/nR/fR*-no-fast-branches . */
43564 
43565 #   ifndef JITTERLISP_UNSAFE
43566       /* Here we can assume that the top object is a closure, without checking:
43567          we either already performed a type check, or the compiler decided it
43568          wasn't necessary. */
43569       jitterlisp_object top = JITTER_TOP_MAINSTACK();
43570       struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
43571 
43572       JITTER_BRANCH_FAST_IF_NOTEQUAL(c->in_arity, JITTER_ARGN0, JITTER_ARGF1);
43573 #   endif // #ifndef JITTERLISP_UNSAFE
43574 
43575     /* End of the user code for *check-in-arity/nR/fR*-no-fast-branches . */
43576 
43577 /* User-specified code, instruction-end-c part: beginning. */
43578 
43579 
43580 /* User-specified code, instruction-end-c part: end */
43581 
43582 #ifdef JITTER_REPLICATE
43583     /* Advance the instruction pointer, if any, to skip residuals;
43584        then jump back to replicated code. */
43585     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
43586     JITTER_SKIP_RESIDUALS_;
43587     goto * _jitter_back_to_replicated_code_pointer;
43588 #endif // #ifdef JITTER_REPLICATE
43589 
43590     /* Undefine the *check-in-arity/nR/fR*-no-fast-branches argument macros so they can't be used
43591        by mistake in the instruction body coming next. */
43592 #   undef JITTER_SLOW_REGISTER_OFFSET0
43593 #   undef JITTER_ARG0
43594 #   undef JITTER_ARGN0
43595 #   undef JITTER_ARGU0
43596 #   undef JITTER_ARGP0
43597 #   undef JITTER_ARGF0
43598 #   undef JITTER_SLOW_REGISTER_OFFSET1
43599 #   undef JITTER_ARG1
43600 #   undef JITTER_ARGN1
43601 #   undef JITTER_ARGU1
43602 #   undef JITTER_ARGP1
43603 #   undef JITTER_ARGF1
43604 
43605 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43606 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43607 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43608 
43609   }
43610 #ifndef JITTER_REPLICATE
43611  JITTER_INSTRUCTION_EPILOG_(*check-in-arity/nR/fR*-no-fast-branches, _Acheck_min_marity__nR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43612 #endif // #ifndef JITTER_REPLICATE
43613 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43614 
43615   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n0/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches, hot)
43616   {
43617     /* This specialized instruction is a replacement. */
43618 #   undef JITTER_BRANCH_FAST
43619 #   define JITTER_BRANCH_FAST JITTER_BRANCH
43620 #   undef JITTER_BRANCH_FAST_IF_ZERO
43621 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
43622 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43623 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
43624 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43625 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
43626 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43627 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
43628 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43629 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
43630 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43631 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
43632 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43633 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
43634 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43635 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
43636 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43637 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
43638 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43639 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
43640 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43641 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
43642 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43643 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
43644 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43645 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
43646 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43647 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
43648 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43649 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
43650 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43651 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
43652 #   undef JITTER_BRANCH_FAST_IF_AND
43653 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
43654 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43655 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
43656 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43657 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
43658 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43659 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
43660 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43661 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
43662 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43663 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
43664 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43665 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
43666 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43667 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
43668 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43669 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
43670 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43671 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
43672 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43673 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
43674 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43675 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
43676 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43677 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
43678 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43679 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
43680 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43681 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
43682     /* This specialized instruction is non-relocatable.
43683        Its 1-th argument, a literal, is the return address where to jump
43684        at the end, back to relocated code. */
43685 
43686 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       233
43687 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n0/fR*-no-fast-branches
43688 
43689 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches
43690 
43691   /* The residual arity for this instruction does not depend on fast labels. */
43692   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
43693 
43694   /* Define argument-access macros for *check-in-arity--alt/n0/fR*-no-fast-branches . */
43695 #ifdef JITTER_HAVE_PATCH_IN
43696   /* Define argument-access macros assuming that fast branches are enabled. */
43697     /* The 0th argument is a nonresidual literal. */
43698 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
43699 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43700 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43701 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43702 
43703     /* The 1th argument is a residual label. */
43704 #if defined(JITTER_DISPATCH_NO_THREADING)
43705 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
43706     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43707 #elif defined (JITTER_REPLICATE)
43708 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
43709 #else
43710 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43711 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43712 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43713 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43714 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43715 #   define JITTER_ARGF1 JITTER_ARGP1
43716 
43717 #else
43718   /* Define argument-access macros assuming that fast branches are disabled. */
43719     /* The 0th argument is a nonresidual literal. */
43720 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 0L})
43721 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43722 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43723 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43724 #   define JITTER_ARGF0 JITTER_ARGP0
43725 
43726     /* The 1th argument is a residual label. */
43727 #if defined(JITTER_DISPATCH_NO_THREADING)
43728 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
43729     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43730 #elif defined (JITTER_REPLICATE)
43731 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
43732 #else
43733 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43734 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43735 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43736 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43737 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43738 #   define JITTER_ARGF1 JITTER_ARGP1
43739 
43740 # endif // #ifdef JITTER_HAVE_PATCH_IN
43741 
43742 #ifdef JITTER_REPLICATE
43743     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
43744        it on the stack rather than in read-only memory.  I had to do this to prevent
43745        a GCC 8 snapshot on SH from being too clever. */
43746     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43747     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
43748        in memory, as a 16-bit constant; and since it reads it with a PC-relative
43749        load the relocated part crashes.
43750                  mov.w     .L1667,r0
43751                  mov.l     @(r0,r15),r1
43752                  jmp       @r1
43753        r15 is the stack pointer.  The constant at .L1667 is
43754           .L1667:
43755                  .short    232
43756        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
43757        can't work as an immediate.  Shall I keep these code pointers as a single array?
43758        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
43759        but the problem will be the same. */
43760     /* Jump to non-relocatable code. */
43761     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
43762 
43763     /* Here the residual arity is given as zero: it's too late to
43764        skip residuals, since we've already jumped and this code is
43765        unreachable.  The instruction pointer, if any, is advanced
43766        in the non-relocatable code. */
43767     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n0/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches, 0)
43768 
43769     /* Relocated code will jump to this label in non-relocated code. */
43770   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
43771     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n0/fR*-no-fast-branches non-relocatable code");
43772 #endif // #ifdef JITTER_REPLICATE
43773 #if defined (JITTER_PROFILE_SAMPLE)
43774   JITTER_PROFILE_SAMPLE_UPDATE
43775      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43776       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43777   /* Force the compiler not move sample-profiling instrumentation
43778      beyond this point; this way the actual user code is timed.
43779      This is still not perfect, as residuals are materialised before
43780      we arrive here, but should be adequate at least for slow VM
43781      instructions. */
43782   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
43783 #endif
43784 #if defined (JITTER_PROFILE_COUNT)
43785   /* Notice that, differently from the code above, this
43786      instrumentation code *can* be reordered freely: as long as a
43787      VM instruction is counted, the count increment can be placed
43788      anyehere.  Let GCC move this code and possibly achieve better
43789      throughput by exploiting instruction-level parallelism and
43790      therefore approximate more closely a non-profiled build. */
43791   JITTER_PROFILE_COUNT_UPDATE
43792      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
43793       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
43794 #endif
43795 
43796 /* User-specified code, instruction-beginning-c part: beginning. */
43797 
43798 
43799 /* User-specified code, instruction-beginning-c part: end */
43800 
43801 
43802     /* User code for *check-in-arity--alt/n0/fR*-no-fast-branches . */
43803 
43804     // FIXME: this loops forever with no-threading (not with the other dispatching models
43805     // including minimal threading) when the callee is compiled.  A Jitter bug.
43806     /* Here we can assume that the top object is a closure, without checking: we either
43807        already performed a type check, or the compiler decided it wasn't necessary. */
43808     jitterlisp_object top = JITTER_TOP_MAINSTACK();
43809     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
43810 
43811     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
43812        from the closure compiledness.  [Done] */
43813     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
43814       {
43815         if (c->in_arity != JITTER_ARGN0)
43816           JITTER_BRANCH_FAST(JITTER_ARGF1);
43817       }
43818     else
43819       {
43820         /* The closure is interpreted.  Compute its in-arity.  We can assume that
43821            the formal list is well-formal, which is to say actually a proper list
43822            of distinct symbols. */
43823         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
43824         jitterlisp_object rest = ic->formals;
43825         jitter_uint in_arity = 0;
43826         while (! JITTERLISP_IS_EMPTY_LIST(rest))
43827           {
43828             in_arity ++;
43829             rest = JITTERLISP_EXP_C_A_CDR(rest);
43830           }
43831         if (in_arity != JITTER_ARGN0)
43832           JITTER_BRANCH_FAST(JITTER_ARGF1);
43833       }
43834 
43835     /* End of the user code for *check-in-arity--alt/n0/fR*-no-fast-branches . */
43836 
43837 /* User-specified code, instruction-end-c part: beginning. */
43838 
43839 
43840 /* User-specified code, instruction-end-c part: end */
43841 
43842 #ifdef JITTER_REPLICATE
43843     /* Advance the instruction pointer, if any, to skip residuals;
43844        then jump back to replicated code. */
43845     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
43846     JITTER_SKIP_RESIDUALS_;
43847     goto * _jitter_back_to_replicated_code_pointer;
43848 #endif // #ifdef JITTER_REPLICATE
43849 
43850     /* Undefine the *check-in-arity--alt/n0/fR*-no-fast-branches argument macros so they can't be used
43851        by mistake in the instruction body coming next. */
43852 #   undef JITTER_SLOW_REGISTER_OFFSET0
43853 #   undef JITTER_ARG0
43854 #   undef JITTER_ARGN0
43855 #   undef JITTER_ARGU0
43856 #   undef JITTER_ARGP0
43857 #   undef JITTER_ARGF0
43858 #   undef JITTER_SLOW_REGISTER_OFFSET1
43859 #   undef JITTER_ARG1
43860 #   undef JITTER_ARGN1
43861 #   undef JITTER_ARGU1
43862 #   undef JITTER_ARGP1
43863 #   undef JITTER_ARGF1
43864 
43865 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
43866 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
43867 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
43868 
43869   }
43870 #ifndef JITTER_REPLICATE
43871  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n0/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n0__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
43872 #endif // #ifndef JITTER_REPLICATE
43873 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
43874 
43875   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n1/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches, hot)
43876   {
43877     /* This specialized instruction is a replacement. */
43878 #   undef JITTER_BRANCH_FAST
43879 #   define JITTER_BRANCH_FAST JITTER_BRANCH
43880 #   undef JITTER_BRANCH_FAST_IF_ZERO
43881 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
43882 #   undef JITTER_BRANCH_FAST_IF_NONZERO
43883 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
43884 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
43885 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
43886 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
43887 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
43888 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
43889 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
43890 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
43891 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
43892 #   undef JITTER_BRANCH_FAST_IF_EQUAL
43893 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
43894 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
43895 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
43896 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
43897 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
43898 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
43899 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
43900 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
43901 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
43902 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
43903 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
43904 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
43905 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
43906 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
43907 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
43908 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
43909 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
43910 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
43911 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
43912 #   undef JITTER_BRANCH_FAST_IF_AND
43913 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
43914 #   undef JITTER_BRANCH_FAST_IF_NOTAND
43915 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
43916 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
43917 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
43918 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
43919 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
43920 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
43921 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
43922 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
43923 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
43924 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
43925 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
43926 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
43927 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
43928 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
43929 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
43930 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
43931 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
43932 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
43933 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
43934 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
43935 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
43936 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
43937 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
43938 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
43939 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
43940 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
43941 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
43942     /* This specialized instruction is non-relocatable.
43943        Its 1-th argument, a literal, is the return address where to jump
43944        at the end, back to relocated code. */
43945 
43946 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       234
43947 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n1/fR*-no-fast-branches
43948 
43949 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches
43950 
43951   /* The residual arity for this instruction does not depend on fast labels. */
43952   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
43953 
43954   /* Define argument-access macros for *check-in-arity--alt/n1/fR*-no-fast-branches . */
43955 #ifdef JITTER_HAVE_PATCH_IN
43956   /* Define argument-access macros assuming that fast branches are enabled. */
43957     /* The 0th argument is a nonresidual literal. */
43958 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
43959 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43960 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43961 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43962 
43963     /* The 1th argument is a residual label. */
43964 #if defined(JITTER_DISPATCH_NO_THREADING)
43965 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
43966     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43967 #elif defined (JITTER_REPLICATE)
43968 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
43969 #else
43970 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43971 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43972 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43973 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43974 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43975 #   define JITTER_ARGF1 JITTER_ARGP1
43976 
43977 #else
43978   /* Define argument-access macros assuming that fast branches are disabled. */
43979     /* The 0th argument is a nonresidual literal. */
43980 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 1L})
43981 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
43982 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
43983 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
43984 #   define JITTER_ARGF0 JITTER_ARGP0
43985 
43986     /* The 1th argument is a residual label. */
43987 #if defined(JITTER_DISPATCH_NO_THREADING)
43988 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
43989     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
43990 #elif defined (JITTER_REPLICATE)
43991 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
43992 #else
43993 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
43994 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
43995 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
43996 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
43997 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
43998 #   define JITTER_ARGF1 JITTER_ARGP1
43999 
44000 # endif // #ifdef JITTER_HAVE_PATCH_IN
44001 
44002 #ifdef JITTER_REPLICATE
44003     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
44004        it on the stack rather than in read-only memory.  I had to do this to prevent
44005        a GCC 8 snapshot on SH from being too clever. */
44006     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44007     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
44008        in memory, as a 16-bit constant; and since it reads it with a PC-relative
44009        load the relocated part crashes.
44010                  mov.w     .L1667,r0
44011                  mov.l     @(r0,r15),r1
44012                  jmp       @r1
44013        r15 is the stack pointer.  The constant at .L1667 is
44014           .L1667:
44015                  .short    232
44016        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
44017        can't work as an immediate.  Shall I keep these code pointers as a single array?
44018        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
44019        but the problem will be the same. */
44020     /* Jump to non-relocatable code. */
44021     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44022 
44023     /* Here the residual arity is given as zero: it's too late to
44024        skip residuals, since we've already jumped and this code is
44025        unreachable.  The instruction pointer, if any, is advanced
44026        in the non-relocatable code. */
44027     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n1/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches, 0)
44028 
44029     /* Relocated code will jump to this label in non-relocated code. */
44030   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
44031     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n1/fR*-no-fast-branches non-relocatable code");
44032 #endif // #ifdef JITTER_REPLICATE
44033 #if defined (JITTER_PROFILE_SAMPLE)
44034   JITTER_PROFILE_SAMPLE_UPDATE
44035      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44036       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44037   /* Force the compiler not move sample-profiling instrumentation
44038      beyond this point; this way the actual user code is timed.
44039      This is still not perfect, as residuals are materialised before
44040      we arrive here, but should be adequate at least for slow VM
44041      instructions. */
44042   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44043 #endif
44044 #if defined (JITTER_PROFILE_COUNT)
44045   /* Notice that, differently from the code above, this
44046      instrumentation code *can* be reordered freely: as long as a
44047      VM instruction is counted, the count increment can be placed
44048      anyehere.  Let GCC move this code and possibly achieve better
44049      throughput by exploiting instruction-level parallelism and
44050      therefore approximate more closely a non-profiled build. */
44051   JITTER_PROFILE_COUNT_UPDATE
44052      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44053       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44054 #endif
44055 
44056 /* User-specified code, instruction-beginning-c part: beginning. */
44057 
44058 
44059 /* User-specified code, instruction-beginning-c part: end */
44060 
44061 
44062     /* User code for *check-in-arity--alt/n1/fR*-no-fast-branches . */
44063 
44064     // FIXME: this loops forever with no-threading (not with the other dispatching models
44065     // including minimal threading) when the callee is compiled.  A Jitter bug.
44066     /* Here we can assume that the top object is a closure, without checking: we either
44067        already performed a type check, or the compiler decided it wasn't necessary. */
44068     jitterlisp_object top = JITTER_TOP_MAINSTACK();
44069     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
44070 
44071     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
44072        from the closure compiledness.  [Done] */
44073     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
44074       {
44075         if (c->in_arity != JITTER_ARGN0)
44076           JITTER_BRANCH_FAST(JITTER_ARGF1);
44077       }
44078     else
44079       {
44080         /* The closure is interpreted.  Compute its in-arity.  We can assume that
44081            the formal list is well-formal, which is to say actually a proper list
44082            of distinct symbols. */
44083         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
44084         jitterlisp_object rest = ic->formals;
44085         jitter_uint in_arity = 0;
44086         while (! JITTERLISP_IS_EMPTY_LIST(rest))
44087           {
44088             in_arity ++;
44089             rest = JITTERLISP_EXP_C_A_CDR(rest);
44090           }
44091         if (in_arity != JITTER_ARGN0)
44092           JITTER_BRANCH_FAST(JITTER_ARGF1);
44093       }
44094 
44095     /* End of the user code for *check-in-arity--alt/n1/fR*-no-fast-branches . */
44096 
44097 /* User-specified code, instruction-end-c part: beginning. */
44098 
44099 
44100 /* User-specified code, instruction-end-c part: end */
44101 
44102 #ifdef JITTER_REPLICATE
44103     /* Advance the instruction pointer, if any, to skip residuals;
44104        then jump back to replicated code. */
44105     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
44106     JITTER_SKIP_RESIDUALS_;
44107     goto * _jitter_back_to_replicated_code_pointer;
44108 #endif // #ifdef JITTER_REPLICATE
44109 
44110     /* Undefine the *check-in-arity--alt/n1/fR*-no-fast-branches argument macros so they can't be used
44111        by mistake in the instruction body coming next. */
44112 #   undef JITTER_SLOW_REGISTER_OFFSET0
44113 #   undef JITTER_ARG0
44114 #   undef JITTER_ARGN0
44115 #   undef JITTER_ARGU0
44116 #   undef JITTER_ARGP0
44117 #   undef JITTER_ARGF0
44118 #   undef JITTER_SLOW_REGISTER_OFFSET1
44119 #   undef JITTER_ARG1
44120 #   undef JITTER_ARGN1
44121 #   undef JITTER_ARGU1
44122 #   undef JITTER_ARGP1
44123 #   undef JITTER_ARGF1
44124 
44125 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44126 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44127 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44128 
44129   }
44130 #ifndef JITTER_REPLICATE
44131  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n1/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n1__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44132 #endif // #ifndef JITTER_REPLICATE
44133 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44134 
44135   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n2/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches, hot)
44136   {
44137     /* This specialized instruction is a replacement. */
44138 #   undef JITTER_BRANCH_FAST
44139 #   define JITTER_BRANCH_FAST JITTER_BRANCH
44140 #   undef JITTER_BRANCH_FAST_IF_ZERO
44141 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
44142 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44143 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
44144 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44145 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
44146 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44147 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
44148 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44149 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
44150 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44151 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
44152 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44153 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
44154 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44155 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
44156 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44157 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
44158 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44159 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
44160 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44161 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
44162 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44163 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
44164 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44165 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
44166 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44167 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
44168 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44169 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
44170 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44171 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
44172 #   undef JITTER_BRANCH_FAST_IF_AND
44173 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
44174 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44175 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
44176 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44177 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
44178 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44179 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
44180 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44181 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
44182 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44183 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
44184 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44185 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
44186 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44187 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
44188 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44189 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
44190 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44191 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
44192 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44193 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
44194 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44195 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
44196 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44197 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
44198 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44199 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
44200 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44201 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
44202     /* This specialized instruction is non-relocatable.
44203        Its 1-th argument, a literal, is the return address where to jump
44204        at the end, back to relocated code. */
44205 
44206 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       235
44207 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n2/fR*-no-fast-branches
44208 
44209 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches
44210 
44211   /* The residual arity for this instruction does not depend on fast labels. */
44212   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
44213 
44214   /* Define argument-access macros for *check-in-arity--alt/n2/fR*-no-fast-branches . */
44215 #ifdef JITTER_HAVE_PATCH_IN
44216   /* Define argument-access macros assuming that fast branches are enabled. */
44217     /* The 0th argument is a nonresidual literal. */
44218 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
44219 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
44220 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
44221 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
44222 
44223     /* The 1th argument is a residual label. */
44224 #if defined(JITTER_DISPATCH_NO_THREADING)
44225 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
44226     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
44227 #elif defined (JITTER_REPLICATE)
44228 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
44229 #else
44230 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
44231 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
44232 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
44233 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
44234 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
44235 #   define JITTER_ARGF1 JITTER_ARGP1
44236 
44237 #else
44238   /* Define argument-access macros assuming that fast branches are disabled. */
44239     /* The 0th argument is a nonresidual literal. */
44240 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 2L})
44241 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
44242 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
44243 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
44244 #   define JITTER_ARGF0 JITTER_ARGP0
44245 
44246     /* The 1th argument is a residual label. */
44247 #if defined(JITTER_DISPATCH_NO_THREADING)
44248 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
44249     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
44250 #elif defined (JITTER_REPLICATE)
44251 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
44252 #else
44253 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
44254 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
44255 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
44256 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
44257 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
44258 #   define JITTER_ARGF1 JITTER_ARGP1
44259 
44260 # endif // #ifdef JITTER_HAVE_PATCH_IN
44261 
44262 #ifdef JITTER_REPLICATE
44263     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
44264        it on the stack rather than in read-only memory.  I had to do this to prevent
44265        a GCC 8 snapshot on SH from being too clever. */
44266     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44267     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
44268        in memory, as a 16-bit constant; and since it reads it with a PC-relative
44269        load the relocated part crashes.
44270                  mov.w     .L1667,r0
44271                  mov.l     @(r0,r15),r1
44272                  jmp       @r1
44273        r15 is the stack pointer.  The constant at .L1667 is
44274           .L1667:
44275                  .short    232
44276        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
44277        can't work as an immediate.  Shall I keep these code pointers as a single array?
44278        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
44279        but the problem will be the same. */
44280     /* Jump to non-relocatable code. */
44281     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44282 
44283     /* Here the residual arity is given as zero: it's too late to
44284        skip residuals, since we've already jumped and this code is
44285        unreachable.  The instruction pointer, if any, is advanced
44286        in the non-relocatable code. */
44287     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n2/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches, 0)
44288 
44289     /* Relocated code will jump to this label in non-relocated code. */
44290   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
44291     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n2/fR*-no-fast-branches non-relocatable code");
44292 #endif // #ifdef JITTER_REPLICATE
44293 #if defined (JITTER_PROFILE_SAMPLE)
44294   JITTER_PROFILE_SAMPLE_UPDATE
44295      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44296       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44297   /* Force the compiler not move sample-profiling instrumentation
44298      beyond this point; this way the actual user code is timed.
44299      This is still not perfect, as residuals are materialised before
44300      we arrive here, but should be adequate at least for slow VM
44301      instructions. */
44302   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44303 #endif
44304 #if defined (JITTER_PROFILE_COUNT)
44305   /* Notice that, differently from the code above, this
44306      instrumentation code *can* be reordered freely: as long as a
44307      VM instruction is counted, the count increment can be placed
44308      anyehere.  Let GCC move this code and possibly achieve better
44309      throughput by exploiting instruction-level parallelism and
44310      therefore approximate more closely a non-profiled build. */
44311   JITTER_PROFILE_COUNT_UPDATE
44312      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44313       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44314 #endif
44315 
44316 /* User-specified code, instruction-beginning-c part: beginning. */
44317 
44318 
44319 /* User-specified code, instruction-beginning-c part: end */
44320 
44321 
44322     /* User code for *check-in-arity--alt/n2/fR*-no-fast-branches . */
44323 
44324     // FIXME: this loops forever with no-threading (not with the other dispatching models
44325     // including minimal threading) when the callee is compiled.  A Jitter bug.
44326     /* Here we can assume that the top object is a closure, without checking: we either
44327        already performed a type check, or the compiler decided it wasn't necessary. */
44328     jitterlisp_object top = JITTER_TOP_MAINSTACK();
44329     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
44330 
44331     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
44332        from the closure compiledness.  [Done] */
44333     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
44334       {
44335         if (c->in_arity != JITTER_ARGN0)
44336           JITTER_BRANCH_FAST(JITTER_ARGF1);
44337       }
44338     else
44339       {
44340         /* The closure is interpreted.  Compute its in-arity.  We can assume that
44341            the formal list is well-formal, which is to say actually a proper list
44342            of distinct symbols. */
44343         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
44344         jitterlisp_object rest = ic->formals;
44345         jitter_uint in_arity = 0;
44346         while (! JITTERLISP_IS_EMPTY_LIST(rest))
44347           {
44348             in_arity ++;
44349             rest = JITTERLISP_EXP_C_A_CDR(rest);
44350           }
44351         if (in_arity != JITTER_ARGN0)
44352           JITTER_BRANCH_FAST(JITTER_ARGF1);
44353       }
44354 
44355     /* End of the user code for *check-in-arity--alt/n2/fR*-no-fast-branches . */
44356 
44357 /* User-specified code, instruction-end-c part: beginning. */
44358 
44359 
44360 /* User-specified code, instruction-end-c part: end */
44361 
44362 #ifdef JITTER_REPLICATE
44363     /* Advance the instruction pointer, if any, to skip residuals;
44364        then jump back to replicated code. */
44365     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
44366     JITTER_SKIP_RESIDUALS_;
44367     goto * _jitter_back_to_replicated_code_pointer;
44368 #endif // #ifdef JITTER_REPLICATE
44369 
44370     /* Undefine the *check-in-arity--alt/n2/fR*-no-fast-branches argument macros so they can't be used
44371        by mistake in the instruction body coming next. */
44372 #   undef JITTER_SLOW_REGISTER_OFFSET0
44373 #   undef JITTER_ARG0
44374 #   undef JITTER_ARGN0
44375 #   undef JITTER_ARGU0
44376 #   undef JITTER_ARGP0
44377 #   undef JITTER_ARGF0
44378 #   undef JITTER_SLOW_REGISTER_OFFSET1
44379 #   undef JITTER_ARG1
44380 #   undef JITTER_ARGN1
44381 #   undef JITTER_ARGU1
44382 #   undef JITTER_ARGP1
44383 #   undef JITTER_ARGF1
44384 
44385 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44386 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44387 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44388 
44389   }
44390 #ifndef JITTER_REPLICATE
44391  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n2/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n2__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44392 #endif // #ifndef JITTER_REPLICATE
44393 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44394 
44395   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n3/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches, hot)
44396   {
44397     /* This specialized instruction is a replacement. */
44398 #   undef JITTER_BRANCH_FAST
44399 #   define JITTER_BRANCH_FAST JITTER_BRANCH
44400 #   undef JITTER_BRANCH_FAST_IF_ZERO
44401 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
44402 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44403 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
44404 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44405 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
44406 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44407 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
44408 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44409 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
44410 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44411 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
44412 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44413 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
44414 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44415 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
44416 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44417 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
44418 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44419 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
44420 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44421 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
44422 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44423 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
44424 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44425 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
44426 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44427 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
44428 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44429 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
44430 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44431 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
44432 #   undef JITTER_BRANCH_FAST_IF_AND
44433 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
44434 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44435 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
44436 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44437 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
44438 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44439 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
44440 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44441 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
44442 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44443 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
44444 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44445 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
44446 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44447 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
44448 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44449 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
44450 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44451 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
44452 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44453 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
44454 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44455 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
44456 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44457 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
44458 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44459 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
44460 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44461 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
44462     /* This specialized instruction is non-relocatable.
44463        Its 1-th argument, a literal, is the return address where to jump
44464        at the end, back to relocated code. */
44465 
44466 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       236
44467 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n3/fR*-no-fast-branches
44468 
44469 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches
44470 
44471   /* The residual arity for this instruction does not depend on fast labels. */
44472   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
44473 
44474   /* Define argument-access macros for *check-in-arity--alt/n3/fR*-no-fast-branches . */
44475 #ifdef JITTER_HAVE_PATCH_IN
44476   /* Define argument-access macros assuming that fast branches are enabled. */
44477     /* The 0th argument is a nonresidual literal. */
44478 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
44479 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
44480 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
44481 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
44482 
44483     /* The 1th argument is a residual label. */
44484 #if defined(JITTER_DISPATCH_NO_THREADING)
44485 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
44486     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
44487 #elif defined (JITTER_REPLICATE)
44488 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
44489 #else
44490 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
44491 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
44492 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
44493 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
44494 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
44495 #   define JITTER_ARGF1 JITTER_ARGP1
44496 
44497 #else
44498   /* Define argument-access macros assuming that fast branches are disabled. */
44499     /* The 0th argument is a nonresidual literal. */
44500 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 3L})
44501 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
44502 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
44503 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
44504 #   define JITTER_ARGF0 JITTER_ARGP0
44505 
44506     /* The 1th argument is a residual label. */
44507 #if defined(JITTER_DISPATCH_NO_THREADING)
44508 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
44509     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
44510 #elif defined (JITTER_REPLICATE)
44511 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
44512 #else
44513 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
44514 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
44515 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
44516 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
44517 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
44518 #   define JITTER_ARGF1 JITTER_ARGP1
44519 
44520 # endif // #ifdef JITTER_HAVE_PATCH_IN
44521 
44522 #ifdef JITTER_REPLICATE
44523     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
44524        it on the stack rather than in read-only memory.  I had to do this to prevent
44525        a GCC 8 snapshot on SH from being too clever. */
44526     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44527     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
44528        in memory, as a 16-bit constant; and since it reads it with a PC-relative
44529        load the relocated part crashes.
44530                  mov.w     .L1667,r0
44531                  mov.l     @(r0,r15),r1
44532                  jmp       @r1
44533        r15 is the stack pointer.  The constant at .L1667 is
44534           .L1667:
44535                  .short    232
44536        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
44537        can't work as an immediate.  Shall I keep these code pointers as a single array?
44538        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
44539        but the problem will be the same. */
44540     /* Jump to non-relocatable code. */
44541     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44542 
44543     /* Here the residual arity is given as zero: it's too late to
44544        skip residuals, since we've already jumped and this code is
44545        unreachable.  The instruction pointer, if any, is advanced
44546        in the non-relocatable code. */
44547     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n3/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches, 0)
44548 
44549     /* Relocated code will jump to this label in non-relocated code. */
44550   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
44551     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n3/fR*-no-fast-branches non-relocatable code");
44552 #endif // #ifdef JITTER_REPLICATE
44553 #if defined (JITTER_PROFILE_SAMPLE)
44554   JITTER_PROFILE_SAMPLE_UPDATE
44555      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44556       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44557   /* Force the compiler not move sample-profiling instrumentation
44558      beyond this point; this way the actual user code is timed.
44559      This is still not perfect, as residuals are materialised before
44560      we arrive here, but should be adequate at least for slow VM
44561      instructions. */
44562   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44563 #endif
44564 #if defined (JITTER_PROFILE_COUNT)
44565   /* Notice that, differently from the code above, this
44566      instrumentation code *can* be reordered freely: as long as a
44567      VM instruction is counted, the count increment can be placed
44568      anyehere.  Let GCC move this code and possibly achieve better
44569      throughput by exploiting instruction-level parallelism and
44570      therefore approximate more closely a non-profiled build. */
44571   JITTER_PROFILE_COUNT_UPDATE
44572      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44573       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44574 #endif
44575 
44576 /* User-specified code, instruction-beginning-c part: beginning. */
44577 
44578 
44579 /* User-specified code, instruction-beginning-c part: end */
44580 
44581 
44582     /* User code for *check-in-arity--alt/n3/fR*-no-fast-branches . */
44583 
44584     // FIXME: this loops forever with no-threading (not with the other dispatching models
44585     // including minimal threading) when the callee is compiled.  A Jitter bug.
44586     /* Here we can assume that the top object is a closure, without checking: we either
44587        already performed a type check, or the compiler decided it wasn't necessary. */
44588     jitterlisp_object top = JITTER_TOP_MAINSTACK();
44589     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
44590 
44591     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
44592        from the closure compiledness.  [Done] */
44593     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
44594       {
44595         if (c->in_arity != JITTER_ARGN0)
44596           JITTER_BRANCH_FAST(JITTER_ARGF1);
44597       }
44598     else
44599       {
44600         /* The closure is interpreted.  Compute its in-arity.  We can assume that
44601            the formal list is well-formal, which is to say actually a proper list
44602            of distinct symbols. */
44603         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
44604         jitterlisp_object rest = ic->formals;
44605         jitter_uint in_arity = 0;
44606         while (! JITTERLISP_IS_EMPTY_LIST(rest))
44607           {
44608             in_arity ++;
44609             rest = JITTERLISP_EXP_C_A_CDR(rest);
44610           }
44611         if (in_arity != JITTER_ARGN0)
44612           JITTER_BRANCH_FAST(JITTER_ARGF1);
44613       }
44614 
44615     /* End of the user code for *check-in-arity--alt/n3/fR*-no-fast-branches . */
44616 
44617 /* User-specified code, instruction-end-c part: beginning. */
44618 
44619 
44620 /* User-specified code, instruction-end-c part: end */
44621 
44622 #ifdef JITTER_REPLICATE
44623     /* Advance the instruction pointer, if any, to skip residuals;
44624        then jump back to replicated code. */
44625     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
44626     JITTER_SKIP_RESIDUALS_;
44627     goto * _jitter_back_to_replicated_code_pointer;
44628 #endif // #ifdef JITTER_REPLICATE
44629 
44630     /* Undefine the *check-in-arity--alt/n3/fR*-no-fast-branches argument macros so they can't be used
44631        by mistake in the instruction body coming next. */
44632 #   undef JITTER_SLOW_REGISTER_OFFSET0
44633 #   undef JITTER_ARG0
44634 #   undef JITTER_ARGN0
44635 #   undef JITTER_ARGU0
44636 #   undef JITTER_ARGP0
44637 #   undef JITTER_ARGF0
44638 #   undef JITTER_SLOW_REGISTER_OFFSET1
44639 #   undef JITTER_ARG1
44640 #   undef JITTER_ARGN1
44641 #   undef JITTER_ARGU1
44642 #   undef JITTER_ARGP1
44643 #   undef JITTER_ARGF1
44644 
44645 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44646 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44647 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44648 
44649   }
44650 #ifndef JITTER_REPLICATE
44651  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n3/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n3__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44652 #endif // #ifndef JITTER_REPLICATE
44653 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44654 
44655   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n4/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches, hot)
44656   {
44657     /* This specialized instruction is a replacement. */
44658 #   undef JITTER_BRANCH_FAST
44659 #   define JITTER_BRANCH_FAST JITTER_BRANCH
44660 #   undef JITTER_BRANCH_FAST_IF_ZERO
44661 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
44662 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44663 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
44664 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44665 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
44666 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44667 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
44668 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44669 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
44670 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44671 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
44672 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44673 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
44674 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44675 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
44676 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44677 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
44678 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44679 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
44680 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44681 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
44682 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44683 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
44684 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44685 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
44686 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44687 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
44688 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44689 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
44690 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44691 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
44692 #   undef JITTER_BRANCH_FAST_IF_AND
44693 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
44694 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44695 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
44696 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44697 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
44698 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44699 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
44700 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44701 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
44702 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44703 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
44704 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44705 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
44706 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44707 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
44708 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44709 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
44710 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44711 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
44712 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44713 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
44714 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44715 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
44716 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44717 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
44718 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44719 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
44720 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44721 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
44722     /* This specialized instruction is non-relocatable.
44723        Its 1-th argument, a literal, is the return address where to jump
44724        at the end, back to relocated code. */
44725 
44726 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       237
44727 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n4/fR*-no-fast-branches
44728 
44729 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches
44730 
44731   /* The residual arity for this instruction does not depend on fast labels. */
44732   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
44733 
44734   /* Define argument-access macros for *check-in-arity--alt/n4/fR*-no-fast-branches . */
44735 #ifdef JITTER_HAVE_PATCH_IN
44736   /* Define argument-access macros assuming that fast branches are enabled. */
44737     /* The 0th argument is a nonresidual literal. */
44738 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
44739 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
44740 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
44741 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
44742 
44743     /* The 1th argument is a residual label. */
44744 #if defined(JITTER_DISPATCH_NO_THREADING)
44745 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
44746     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
44747 #elif defined (JITTER_REPLICATE)
44748 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
44749 #else
44750 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
44751 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
44752 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
44753 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
44754 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
44755 #   define JITTER_ARGF1 JITTER_ARGP1
44756 
44757 #else
44758   /* Define argument-access macros assuming that fast branches are disabled. */
44759     /* The 0th argument is a nonresidual literal. */
44760 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 4L})
44761 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
44762 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
44763 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
44764 #   define JITTER_ARGF0 JITTER_ARGP0
44765 
44766     /* The 1th argument is a residual label. */
44767 #if defined(JITTER_DISPATCH_NO_THREADING)
44768 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
44769     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
44770 #elif defined (JITTER_REPLICATE)
44771 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
44772 #else
44773 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
44774 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
44775 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
44776 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
44777 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
44778 #   define JITTER_ARGF1 JITTER_ARGP1
44779 
44780 # endif // #ifdef JITTER_HAVE_PATCH_IN
44781 
44782 #ifdef JITTER_REPLICATE
44783     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
44784        it on the stack rather than in read-only memory.  I had to do this to prevent
44785        a GCC 8 snapshot on SH from being too clever. */
44786     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44787     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
44788        in memory, as a 16-bit constant; and since it reads it with a PC-relative
44789        load the relocated part crashes.
44790                  mov.w     .L1667,r0
44791                  mov.l     @(r0,r15),r1
44792                  jmp       @r1
44793        r15 is the stack pointer.  The constant at .L1667 is
44794           .L1667:
44795                  .short    232
44796        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
44797        can't work as an immediate.  Shall I keep these code pointers as a single array?
44798        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
44799        but the problem will be the same. */
44800     /* Jump to non-relocatable code. */
44801     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
44802 
44803     /* Here the residual arity is given as zero: it's too late to
44804        skip residuals, since we've already jumped and this code is
44805        unreachable.  The instruction pointer, if any, is advanced
44806        in the non-relocatable code. */
44807     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n4/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches, 0)
44808 
44809     /* Relocated code will jump to this label in non-relocated code. */
44810   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
44811     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n4/fR*-no-fast-branches non-relocatable code");
44812 #endif // #ifdef JITTER_REPLICATE
44813 #if defined (JITTER_PROFILE_SAMPLE)
44814   JITTER_PROFILE_SAMPLE_UPDATE
44815      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44816       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44817   /* Force the compiler not move sample-profiling instrumentation
44818      beyond this point; this way the actual user code is timed.
44819      This is still not perfect, as residuals are materialised before
44820      we arrive here, but should be adequate at least for slow VM
44821      instructions. */
44822   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
44823 #endif
44824 #if defined (JITTER_PROFILE_COUNT)
44825   /* Notice that, differently from the code above, this
44826      instrumentation code *can* be reordered freely: as long as a
44827      VM instruction is counted, the count increment can be placed
44828      anyehere.  Let GCC move this code and possibly achieve better
44829      throughput by exploiting instruction-level parallelism and
44830      therefore approximate more closely a non-profiled build. */
44831   JITTER_PROFILE_COUNT_UPDATE
44832      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
44833       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
44834 #endif
44835 
44836 /* User-specified code, instruction-beginning-c part: beginning. */
44837 
44838 
44839 /* User-specified code, instruction-beginning-c part: end */
44840 
44841 
44842     /* User code for *check-in-arity--alt/n4/fR*-no-fast-branches . */
44843 
44844     // FIXME: this loops forever with no-threading (not with the other dispatching models
44845     // including minimal threading) when the callee is compiled.  A Jitter bug.
44846     /* Here we can assume that the top object is a closure, without checking: we either
44847        already performed a type check, or the compiler decided it wasn't necessary. */
44848     jitterlisp_object top = JITTER_TOP_MAINSTACK();
44849     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
44850 
44851     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
44852        from the closure compiledness.  [Done] */
44853     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
44854       {
44855         if (c->in_arity != JITTER_ARGN0)
44856           JITTER_BRANCH_FAST(JITTER_ARGF1);
44857       }
44858     else
44859       {
44860         /* The closure is interpreted.  Compute its in-arity.  We can assume that
44861            the formal list is well-formal, which is to say actually a proper list
44862            of distinct symbols. */
44863         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
44864         jitterlisp_object rest = ic->formals;
44865         jitter_uint in_arity = 0;
44866         while (! JITTERLISP_IS_EMPTY_LIST(rest))
44867           {
44868             in_arity ++;
44869             rest = JITTERLISP_EXP_C_A_CDR(rest);
44870           }
44871         if (in_arity != JITTER_ARGN0)
44872           JITTER_BRANCH_FAST(JITTER_ARGF1);
44873       }
44874 
44875     /* End of the user code for *check-in-arity--alt/n4/fR*-no-fast-branches . */
44876 
44877 /* User-specified code, instruction-end-c part: beginning. */
44878 
44879 
44880 /* User-specified code, instruction-end-c part: end */
44881 
44882 #ifdef JITTER_REPLICATE
44883     /* Advance the instruction pointer, if any, to skip residuals;
44884        then jump back to replicated code. */
44885     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
44886     JITTER_SKIP_RESIDUALS_;
44887     goto * _jitter_back_to_replicated_code_pointer;
44888 #endif // #ifdef JITTER_REPLICATE
44889 
44890     /* Undefine the *check-in-arity--alt/n4/fR*-no-fast-branches argument macros so they can't be used
44891        by mistake in the instruction body coming next. */
44892 #   undef JITTER_SLOW_REGISTER_OFFSET0
44893 #   undef JITTER_ARG0
44894 #   undef JITTER_ARGN0
44895 #   undef JITTER_ARGU0
44896 #   undef JITTER_ARGP0
44897 #   undef JITTER_ARGF0
44898 #   undef JITTER_SLOW_REGISTER_OFFSET1
44899 #   undef JITTER_ARG1
44900 #   undef JITTER_ARGN1
44901 #   undef JITTER_ARGU1
44902 #   undef JITTER_ARGP1
44903 #   undef JITTER_ARGF1
44904 
44905 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
44906 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
44907 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
44908 
44909   }
44910 #ifndef JITTER_REPLICATE
44911  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n4/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n4__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
44912 #endif // #ifndef JITTER_REPLICATE
44913 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
44914 
44915   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n5/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches, hot)
44916   {
44917     /* This specialized instruction is a replacement. */
44918 #   undef JITTER_BRANCH_FAST
44919 #   define JITTER_BRANCH_FAST JITTER_BRANCH
44920 #   undef JITTER_BRANCH_FAST_IF_ZERO
44921 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
44922 #   undef JITTER_BRANCH_FAST_IF_NONZERO
44923 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
44924 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
44925 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
44926 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
44927 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
44928 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
44929 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
44930 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
44931 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
44932 #   undef JITTER_BRANCH_FAST_IF_EQUAL
44933 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
44934 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
44935 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
44936 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
44937 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
44938 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
44939 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
44940 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
44941 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
44942 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
44943 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
44944 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
44945 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
44946 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
44947 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
44948 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
44949 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
44950 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
44951 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
44952 #   undef JITTER_BRANCH_FAST_IF_AND
44953 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
44954 #   undef JITTER_BRANCH_FAST_IF_NOTAND
44955 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
44956 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
44957 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
44958 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
44959 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
44960 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
44961 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
44962 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
44963 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
44964 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
44965 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
44966 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
44967 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
44968 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
44969 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
44970 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
44971 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
44972 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
44973 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
44974 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
44975 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
44976 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
44977 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
44978 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
44979 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
44980 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
44981 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
44982     /* This specialized instruction is non-relocatable.
44983        Its 1-th argument, a literal, is the return address where to jump
44984        at the end, back to relocated code. */
44985 
44986 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       238
44987 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n5/fR*-no-fast-branches
44988 
44989 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches
44990 
44991   /* The residual arity for this instruction does not depend on fast labels. */
44992   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
44993 
44994   /* Define argument-access macros for *check-in-arity--alt/n5/fR*-no-fast-branches . */
44995 #ifdef JITTER_HAVE_PATCH_IN
44996   /* Define argument-access macros assuming that fast branches are enabled. */
44997     /* The 0th argument is a nonresidual literal. */
44998 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
44999 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45000 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45001 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45002 
45003     /* The 1th argument is a residual label. */
45004 #if defined(JITTER_DISPATCH_NO_THREADING)
45005 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45006     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45007 #elif defined (JITTER_REPLICATE)
45008 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45009 #else
45010 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45011 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45012 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45013 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45014 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45015 #   define JITTER_ARGF1 JITTER_ARGP1
45016 
45017 #else
45018   /* Define argument-access macros assuming that fast branches are disabled. */
45019     /* The 0th argument is a nonresidual literal. */
45020 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 5L})
45021 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45022 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45023 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45024 #   define JITTER_ARGF0 JITTER_ARGP0
45025 
45026     /* The 1th argument is a residual label. */
45027 #if defined(JITTER_DISPATCH_NO_THREADING)
45028 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45029     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45030 #elif defined (JITTER_REPLICATE)
45031 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45032 #else
45033 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45034 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45035 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45036 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45037 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45038 #   define JITTER_ARGF1 JITTER_ARGP1
45039 
45040 # endif // #ifdef JITTER_HAVE_PATCH_IN
45041 
45042 #ifdef JITTER_REPLICATE
45043     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
45044        it on the stack rather than in read-only memory.  I had to do this to prevent
45045        a GCC 8 snapshot on SH from being too clever. */
45046     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45047     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
45048        in memory, as a 16-bit constant; and since it reads it with a PC-relative
45049        load the relocated part crashes.
45050                  mov.w     .L1667,r0
45051                  mov.l     @(r0,r15),r1
45052                  jmp       @r1
45053        r15 is the stack pointer.  The constant at .L1667 is
45054           .L1667:
45055                  .short    232
45056        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
45057        can't work as an immediate.  Shall I keep these code pointers as a single array?
45058        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
45059        but the problem will be the same. */
45060     /* Jump to non-relocatable code. */
45061     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45062 
45063     /* Here the residual arity is given as zero: it's too late to
45064        skip residuals, since we've already jumped and this code is
45065        unreachable.  The instruction pointer, if any, is advanced
45066        in the non-relocatable code. */
45067     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n5/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches, 0)
45068 
45069     /* Relocated code will jump to this label in non-relocated code. */
45070   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
45071     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n5/fR*-no-fast-branches non-relocatable code");
45072 #endif // #ifdef JITTER_REPLICATE
45073 #if defined (JITTER_PROFILE_SAMPLE)
45074   JITTER_PROFILE_SAMPLE_UPDATE
45075      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45076       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45077   /* Force the compiler not move sample-profiling instrumentation
45078      beyond this point; this way the actual user code is timed.
45079      This is still not perfect, as residuals are materialised before
45080      we arrive here, but should be adequate at least for slow VM
45081      instructions. */
45082   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45083 #endif
45084 #if defined (JITTER_PROFILE_COUNT)
45085   /* Notice that, differently from the code above, this
45086      instrumentation code *can* be reordered freely: as long as a
45087      VM instruction is counted, the count increment can be placed
45088      anyehere.  Let GCC move this code and possibly achieve better
45089      throughput by exploiting instruction-level parallelism and
45090      therefore approximate more closely a non-profiled build. */
45091   JITTER_PROFILE_COUNT_UPDATE
45092      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45093       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45094 #endif
45095 
45096 /* User-specified code, instruction-beginning-c part: beginning. */
45097 
45098 
45099 /* User-specified code, instruction-beginning-c part: end */
45100 
45101 
45102     /* User code for *check-in-arity--alt/n5/fR*-no-fast-branches . */
45103 
45104     // FIXME: this loops forever with no-threading (not with the other dispatching models
45105     // including minimal threading) when the callee is compiled.  A Jitter bug.
45106     /* Here we can assume that the top object is a closure, without checking: we either
45107        already performed a type check, or the compiler decided it wasn't necessary. */
45108     jitterlisp_object top = JITTER_TOP_MAINSTACK();
45109     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
45110 
45111     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
45112        from the closure compiledness.  [Done] */
45113     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
45114       {
45115         if (c->in_arity != JITTER_ARGN0)
45116           JITTER_BRANCH_FAST(JITTER_ARGF1);
45117       }
45118     else
45119       {
45120         /* The closure is interpreted.  Compute its in-arity.  We can assume that
45121            the formal list is well-formal, which is to say actually a proper list
45122            of distinct symbols. */
45123         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
45124         jitterlisp_object rest = ic->formals;
45125         jitter_uint in_arity = 0;
45126         while (! JITTERLISP_IS_EMPTY_LIST(rest))
45127           {
45128             in_arity ++;
45129             rest = JITTERLISP_EXP_C_A_CDR(rest);
45130           }
45131         if (in_arity != JITTER_ARGN0)
45132           JITTER_BRANCH_FAST(JITTER_ARGF1);
45133       }
45134 
45135     /* End of the user code for *check-in-arity--alt/n5/fR*-no-fast-branches . */
45136 
45137 /* User-specified code, instruction-end-c part: beginning. */
45138 
45139 
45140 /* User-specified code, instruction-end-c part: end */
45141 
45142 #ifdef JITTER_REPLICATE
45143     /* Advance the instruction pointer, if any, to skip residuals;
45144        then jump back to replicated code. */
45145     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
45146     JITTER_SKIP_RESIDUALS_;
45147     goto * _jitter_back_to_replicated_code_pointer;
45148 #endif // #ifdef JITTER_REPLICATE
45149 
45150     /* Undefine the *check-in-arity--alt/n5/fR*-no-fast-branches argument macros so they can't be used
45151        by mistake in the instruction body coming next. */
45152 #   undef JITTER_SLOW_REGISTER_OFFSET0
45153 #   undef JITTER_ARG0
45154 #   undef JITTER_ARGN0
45155 #   undef JITTER_ARGU0
45156 #   undef JITTER_ARGP0
45157 #   undef JITTER_ARGF0
45158 #   undef JITTER_SLOW_REGISTER_OFFSET1
45159 #   undef JITTER_ARG1
45160 #   undef JITTER_ARGN1
45161 #   undef JITTER_ARGU1
45162 #   undef JITTER_ARGP1
45163 #   undef JITTER_ARGF1
45164 
45165 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45166 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45167 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45168 
45169   }
45170 #ifndef JITTER_REPLICATE
45171  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n5/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n5__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45172 #endif // #ifndef JITTER_REPLICATE
45173 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45174 
45175   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n6/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches, hot)
45176   {
45177     /* This specialized instruction is a replacement. */
45178 #   undef JITTER_BRANCH_FAST
45179 #   define JITTER_BRANCH_FAST JITTER_BRANCH
45180 #   undef JITTER_BRANCH_FAST_IF_ZERO
45181 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
45182 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45183 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
45184 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45185 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
45186 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45187 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
45188 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45189 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
45190 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45191 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
45192 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45193 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
45194 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45195 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
45196 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45197 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
45198 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45199 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
45200 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45201 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
45202 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45203 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
45204 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45205 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
45206 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45207 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
45208 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45209 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
45210 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45211 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
45212 #   undef JITTER_BRANCH_FAST_IF_AND
45213 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
45214 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45215 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
45216 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45217 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
45218 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45219 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
45220 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45221 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
45222 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45223 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
45224 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45225 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
45226 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45227 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
45228 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45229 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
45230 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45231 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
45232 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45233 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
45234 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45235 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
45236 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45237 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
45238 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45239 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
45240 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45241 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
45242     /* This specialized instruction is non-relocatable.
45243        Its 1-th argument, a literal, is the return address where to jump
45244        at the end, back to relocated code. */
45245 
45246 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       239
45247 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n6/fR*-no-fast-branches
45248 
45249 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches
45250 
45251   /* The residual arity for this instruction does not depend on fast labels. */
45252   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
45253 
45254   /* Define argument-access macros for *check-in-arity--alt/n6/fR*-no-fast-branches . */
45255 #ifdef JITTER_HAVE_PATCH_IN
45256   /* Define argument-access macros assuming that fast branches are enabled. */
45257     /* The 0th argument is a nonresidual literal. */
45258 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
45259 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45260 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45261 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45262 
45263     /* The 1th argument is a residual label. */
45264 #if defined(JITTER_DISPATCH_NO_THREADING)
45265 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45266     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45267 #elif defined (JITTER_REPLICATE)
45268 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45269 #else
45270 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45271 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45272 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45273 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45274 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45275 #   define JITTER_ARGF1 JITTER_ARGP1
45276 
45277 #else
45278   /* Define argument-access macros assuming that fast branches are disabled. */
45279     /* The 0th argument is a nonresidual literal. */
45280 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 6L})
45281 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45282 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45283 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45284 #   define JITTER_ARGF0 JITTER_ARGP0
45285 
45286     /* The 1th argument is a residual label. */
45287 #if defined(JITTER_DISPATCH_NO_THREADING)
45288 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45289     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45290 #elif defined (JITTER_REPLICATE)
45291 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45292 #else
45293 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45294 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45295 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45296 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45297 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45298 #   define JITTER_ARGF1 JITTER_ARGP1
45299 
45300 # endif // #ifdef JITTER_HAVE_PATCH_IN
45301 
45302 #ifdef JITTER_REPLICATE
45303     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
45304        it on the stack rather than in read-only memory.  I had to do this to prevent
45305        a GCC 8 snapshot on SH from being too clever. */
45306     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45307     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
45308        in memory, as a 16-bit constant; and since it reads it with a PC-relative
45309        load the relocated part crashes.
45310                  mov.w     .L1667,r0
45311                  mov.l     @(r0,r15),r1
45312                  jmp       @r1
45313        r15 is the stack pointer.  The constant at .L1667 is
45314           .L1667:
45315                  .short    232
45316        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
45317        can't work as an immediate.  Shall I keep these code pointers as a single array?
45318        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
45319        but the problem will be the same. */
45320     /* Jump to non-relocatable code. */
45321     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45322 
45323     /* Here the residual arity is given as zero: it's too late to
45324        skip residuals, since we've already jumped and this code is
45325        unreachable.  The instruction pointer, if any, is advanced
45326        in the non-relocatable code. */
45327     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n6/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches, 0)
45328 
45329     /* Relocated code will jump to this label in non-relocated code. */
45330   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
45331     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n6/fR*-no-fast-branches non-relocatable code");
45332 #endif // #ifdef JITTER_REPLICATE
45333 #if defined (JITTER_PROFILE_SAMPLE)
45334   JITTER_PROFILE_SAMPLE_UPDATE
45335      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45336       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45337   /* Force the compiler not move sample-profiling instrumentation
45338      beyond this point; this way the actual user code is timed.
45339      This is still not perfect, as residuals are materialised before
45340      we arrive here, but should be adequate at least for slow VM
45341      instructions. */
45342   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45343 #endif
45344 #if defined (JITTER_PROFILE_COUNT)
45345   /* Notice that, differently from the code above, this
45346      instrumentation code *can* be reordered freely: as long as a
45347      VM instruction is counted, the count increment can be placed
45348      anyehere.  Let GCC move this code and possibly achieve better
45349      throughput by exploiting instruction-level parallelism and
45350      therefore approximate more closely a non-profiled build. */
45351   JITTER_PROFILE_COUNT_UPDATE
45352      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45353       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45354 #endif
45355 
45356 /* User-specified code, instruction-beginning-c part: beginning. */
45357 
45358 
45359 /* User-specified code, instruction-beginning-c part: end */
45360 
45361 
45362     /* User code for *check-in-arity--alt/n6/fR*-no-fast-branches . */
45363 
45364     // FIXME: this loops forever with no-threading (not with the other dispatching models
45365     // including minimal threading) when the callee is compiled.  A Jitter bug.
45366     /* Here we can assume that the top object is a closure, without checking: we either
45367        already performed a type check, or the compiler decided it wasn't necessary. */
45368     jitterlisp_object top = JITTER_TOP_MAINSTACK();
45369     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
45370 
45371     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
45372        from the closure compiledness.  [Done] */
45373     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
45374       {
45375         if (c->in_arity != JITTER_ARGN0)
45376           JITTER_BRANCH_FAST(JITTER_ARGF1);
45377       }
45378     else
45379       {
45380         /* The closure is interpreted.  Compute its in-arity.  We can assume that
45381            the formal list is well-formal, which is to say actually a proper list
45382            of distinct symbols. */
45383         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
45384         jitterlisp_object rest = ic->formals;
45385         jitter_uint in_arity = 0;
45386         while (! JITTERLISP_IS_EMPTY_LIST(rest))
45387           {
45388             in_arity ++;
45389             rest = JITTERLISP_EXP_C_A_CDR(rest);
45390           }
45391         if (in_arity != JITTER_ARGN0)
45392           JITTER_BRANCH_FAST(JITTER_ARGF1);
45393       }
45394 
45395     /* End of the user code for *check-in-arity--alt/n6/fR*-no-fast-branches . */
45396 
45397 /* User-specified code, instruction-end-c part: beginning. */
45398 
45399 
45400 /* User-specified code, instruction-end-c part: end */
45401 
45402 #ifdef JITTER_REPLICATE
45403     /* Advance the instruction pointer, if any, to skip residuals;
45404        then jump back to replicated code. */
45405     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
45406     JITTER_SKIP_RESIDUALS_;
45407     goto * _jitter_back_to_replicated_code_pointer;
45408 #endif // #ifdef JITTER_REPLICATE
45409 
45410     /* Undefine the *check-in-arity--alt/n6/fR*-no-fast-branches argument macros so they can't be used
45411        by mistake in the instruction body coming next. */
45412 #   undef JITTER_SLOW_REGISTER_OFFSET0
45413 #   undef JITTER_ARG0
45414 #   undef JITTER_ARGN0
45415 #   undef JITTER_ARGU0
45416 #   undef JITTER_ARGP0
45417 #   undef JITTER_ARGF0
45418 #   undef JITTER_SLOW_REGISTER_OFFSET1
45419 #   undef JITTER_ARG1
45420 #   undef JITTER_ARGN1
45421 #   undef JITTER_ARGU1
45422 #   undef JITTER_ARGP1
45423 #   undef JITTER_ARGF1
45424 
45425 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45426 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45427 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45428 
45429   }
45430 #ifndef JITTER_REPLICATE
45431  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n6/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n6__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45432 #endif // #ifndef JITTER_REPLICATE
45433 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45434 
45435   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n7/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches, hot)
45436   {
45437     /* This specialized instruction is a replacement. */
45438 #   undef JITTER_BRANCH_FAST
45439 #   define JITTER_BRANCH_FAST JITTER_BRANCH
45440 #   undef JITTER_BRANCH_FAST_IF_ZERO
45441 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
45442 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45443 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
45444 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45445 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
45446 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45447 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
45448 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45449 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
45450 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45451 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
45452 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45453 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
45454 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45455 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
45456 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45457 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
45458 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45459 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
45460 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45461 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
45462 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45463 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
45464 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45465 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
45466 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45467 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
45468 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45469 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
45470 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45471 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
45472 #   undef JITTER_BRANCH_FAST_IF_AND
45473 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
45474 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45475 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
45476 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45477 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
45478 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45479 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
45480 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45481 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
45482 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45483 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
45484 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45485 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
45486 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45487 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
45488 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45489 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
45490 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45491 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
45492 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45493 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
45494 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45495 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
45496 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45497 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
45498 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45499 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
45500 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45501 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
45502     /* This specialized instruction is non-relocatable.
45503        Its 1-th argument, a literal, is the return address where to jump
45504        at the end, back to relocated code. */
45505 
45506 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       240
45507 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n7/fR*-no-fast-branches
45508 
45509 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches
45510 
45511   /* The residual arity for this instruction does not depend on fast labels. */
45512   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
45513 
45514   /* Define argument-access macros for *check-in-arity--alt/n7/fR*-no-fast-branches . */
45515 #ifdef JITTER_HAVE_PATCH_IN
45516   /* Define argument-access macros assuming that fast branches are enabled. */
45517     /* The 0th argument is a nonresidual literal. */
45518 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
45519 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45520 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45521 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45522 
45523     /* The 1th argument is a residual label. */
45524 #if defined(JITTER_DISPATCH_NO_THREADING)
45525 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45526     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45527 #elif defined (JITTER_REPLICATE)
45528 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45529 #else
45530 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45531 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45532 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45533 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45534 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45535 #   define JITTER_ARGF1 JITTER_ARGP1
45536 
45537 #else
45538   /* Define argument-access macros assuming that fast branches are disabled. */
45539     /* The 0th argument is a nonresidual literal. */
45540 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 7L})
45541 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45542 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45543 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45544 #   define JITTER_ARGF0 JITTER_ARGP0
45545 
45546     /* The 1th argument is a residual label. */
45547 #if defined(JITTER_DISPATCH_NO_THREADING)
45548 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45549     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45550 #elif defined (JITTER_REPLICATE)
45551 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45552 #else
45553 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45554 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45555 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45556 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45557 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45558 #   define JITTER_ARGF1 JITTER_ARGP1
45559 
45560 # endif // #ifdef JITTER_HAVE_PATCH_IN
45561 
45562 #ifdef JITTER_REPLICATE
45563     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
45564        it on the stack rather than in read-only memory.  I had to do this to prevent
45565        a GCC 8 snapshot on SH from being too clever. */
45566     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45567     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
45568        in memory, as a 16-bit constant; and since it reads it with a PC-relative
45569        load the relocated part crashes.
45570                  mov.w     .L1667,r0
45571                  mov.l     @(r0,r15),r1
45572                  jmp       @r1
45573        r15 is the stack pointer.  The constant at .L1667 is
45574           .L1667:
45575                  .short    232
45576        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
45577        can't work as an immediate.  Shall I keep these code pointers as a single array?
45578        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
45579        but the problem will be the same. */
45580     /* Jump to non-relocatable code. */
45581     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45582 
45583     /* Here the residual arity is given as zero: it's too late to
45584        skip residuals, since we've already jumped and this code is
45585        unreachable.  The instruction pointer, if any, is advanced
45586        in the non-relocatable code. */
45587     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n7/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches, 0)
45588 
45589     /* Relocated code will jump to this label in non-relocated code. */
45590   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
45591     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n7/fR*-no-fast-branches non-relocatable code");
45592 #endif // #ifdef JITTER_REPLICATE
45593 #if defined (JITTER_PROFILE_SAMPLE)
45594   JITTER_PROFILE_SAMPLE_UPDATE
45595      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45596       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45597   /* Force the compiler not move sample-profiling instrumentation
45598      beyond this point; this way the actual user code is timed.
45599      This is still not perfect, as residuals are materialised before
45600      we arrive here, but should be adequate at least for slow VM
45601      instructions. */
45602   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45603 #endif
45604 #if defined (JITTER_PROFILE_COUNT)
45605   /* Notice that, differently from the code above, this
45606      instrumentation code *can* be reordered freely: as long as a
45607      VM instruction is counted, the count increment can be placed
45608      anyehere.  Let GCC move this code and possibly achieve better
45609      throughput by exploiting instruction-level parallelism and
45610      therefore approximate more closely a non-profiled build. */
45611   JITTER_PROFILE_COUNT_UPDATE
45612      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45613       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45614 #endif
45615 
45616 /* User-specified code, instruction-beginning-c part: beginning. */
45617 
45618 
45619 /* User-specified code, instruction-beginning-c part: end */
45620 
45621 
45622     /* User code for *check-in-arity--alt/n7/fR*-no-fast-branches . */
45623 
45624     // FIXME: this loops forever with no-threading (not with the other dispatching models
45625     // including minimal threading) when the callee is compiled.  A Jitter bug.
45626     /* Here we can assume that the top object is a closure, without checking: we either
45627        already performed a type check, or the compiler decided it wasn't necessary. */
45628     jitterlisp_object top = JITTER_TOP_MAINSTACK();
45629     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
45630 
45631     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
45632        from the closure compiledness.  [Done] */
45633     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
45634       {
45635         if (c->in_arity != JITTER_ARGN0)
45636           JITTER_BRANCH_FAST(JITTER_ARGF1);
45637       }
45638     else
45639       {
45640         /* The closure is interpreted.  Compute its in-arity.  We can assume that
45641            the formal list is well-formal, which is to say actually a proper list
45642            of distinct symbols. */
45643         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
45644         jitterlisp_object rest = ic->formals;
45645         jitter_uint in_arity = 0;
45646         while (! JITTERLISP_IS_EMPTY_LIST(rest))
45647           {
45648             in_arity ++;
45649             rest = JITTERLISP_EXP_C_A_CDR(rest);
45650           }
45651         if (in_arity != JITTER_ARGN0)
45652           JITTER_BRANCH_FAST(JITTER_ARGF1);
45653       }
45654 
45655     /* End of the user code for *check-in-arity--alt/n7/fR*-no-fast-branches . */
45656 
45657 /* User-specified code, instruction-end-c part: beginning. */
45658 
45659 
45660 /* User-specified code, instruction-end-c part: end */
45661 
45662 #ifdef JITTER_REPLICATE
45663     /* Advance the instruction pointer, if any, to skip residuals;
45664        then jump back to replicated code. */
45665     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
45666     JITTER_SKIP_RESIDUALS_;
45667     goto * _jitter_back_to_replicated_code_pointer;
45668 #endif // #ifdef JITTER_REPLICATE
45669 
45670     /* Undefine the *check-in-arity--alt/n7/fR*-no-fast-branches argument macros so they can't be used
45671        by mistake in the instruction body coming next. */
45672 #   undef JITTER_SLOW_REGISTER_OFFSET0
45673 #   undef JITTER_ARG0
45674 #   undef JITTER_ARGN0
45675 #   undef JITTER_ARGU0
45676 #   undef JITTER_ARGP0
45677 #   undef JITTER_ARGF0
45678 #   undef JITTER_SLOW_REGISTER_OFFSET1
45679 #   undef JITTER_ARG1
45680 #   undef JITTER_ARGN1
45681 #   undef JITTER_ARGU1
45682 #   undef JITTER_ARGP1
45683 #   undef JITTER_ARGF1
45684 
45685 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45686 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45687 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45688 
45689   }
45690 #ifndef JITTER_REPLICATE
45691  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n7/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n7__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45692 #endif // #ifndef JITTER_REPLICATE
45693 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45694 
45695   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n8/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches, hot)
45696   {
45697     /* This specialized instruction is a replacement. */
45698 #   undef JITTER_BRANCH_FAST
45699 #   define JITTER_BRANCH_FAST JITTER_BRANCH
45700 #   undef JITTER_BRANCH_FAST_IF_ZERO
45701 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
45702 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45703 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
45704 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45705 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
45706 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45707 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
45708 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45709 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
45710 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45711 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
45712 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45713 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
45714 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45715 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
45716 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45717 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
45718 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45719 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
45720 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45721 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
45722 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45723 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
45724 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45725 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
45726 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45727 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
45728 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45729 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
45730 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45731 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
45732 #   undef JITTER_BRANCH_FAST_IF_AND
45733 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
45734 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45735 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
45736 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45737 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
45738 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45739 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
45740 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
45741 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
45742 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
45743 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
45744 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
45745 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
45746 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
45747 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
45748 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
45749 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
45750 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
45751 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
45752 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
45753 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
45754 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
45755 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
45756 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
45757 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
45758 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
45759 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
45760 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
45761 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
45762     /* This specialized instruction is non-relocatable.
45763        Its 1-th argument, a literal, is the return address where to jump
45764        at the end, back to relocated code. */
45765 
45766 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       241
45767 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n8/fR*-no-fast-branches
45768 
45769 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches
45770 
45771   /* The residual arity for this instruction does not depend on fast labels. */
45772   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
45773 
45774   /* Define argument-access macros for *check-in-arity--alt/n8/fR*-no-fast-branches . */
45775 #ifdef JITTER_HAVE_PATCH_IN
45776   /* Define argument-access macros assuming that fast branches are enabled. */
45777     /* The 0th argument is a nonresidual literal. */
45778 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
45779 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45780 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45781 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45782 
45783     /* The 1th argument is a residual label. */
45784 #if defined(JITTER_DISPATCH_NO_THREADING)
45785 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45786     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45787 #elif defined (JITTER_REPLICATE)
45788 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45789 #else
45790 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45791 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45792 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45793 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45794 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45795 #   define JITTER_ARGF1 JITTER_ARGP1
45796 
45797 #else
45798   /* Define argument-access macros assuming that fast branches are disabled. */
45799     /* The 0th argument is a nonresidual literal. */
45800 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 8L})
45801 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
45802 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
45803 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
45804 #   define JITTER_ARGF0 JITTER_ARGP0
45805 
45806     /* The 1th argument is a residual label. */
45807 #if defined(JITTER_DISPATCH_NO_THREADING)
45808 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
45809     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
45810 #elif defined (JITTER_REPLICATE)
45811 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
45812 #else
45813 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
45814 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
45815 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
45816 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
45817 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
45818 #   define JITTER_ARGF1 JITTER_ARGP1
45819 
45820 # endif // #ifdef JITTER_HAVE_PATCH_IN
45821 
45822 #ifdef JITTER_REPLICATE
45823     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
45824        it on the stack rather than in read-only memory.  I had to do this to prevent
45825        a GCC 8 snapshot on SH from being too clever. */
45826     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45827     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
45828        in memory, as a 16-bit constant; and since it reads it with a PC-relative
45829        load the relocated part crashes.
45830                  mov.w     .L1667,r0
45831                  mov.l     @(r0,r15),r1
45832                  jmp       @r1
45833        r15 is the stack pointer.  The constant at .L1667 is
45834           .L1667:
45835                  .short    232
45836        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
45837        can't work as an immediate.  Shall I keep these code pointers as a single array?
45838        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
45839        but the problem will be the same. */
45840     /* Jump to non-relocatable code. */
45841     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
45842 
45843     /* Here the residual arity is given as zero: it's too late to
45844        skip residuals, since we've already jumped and this code is
45845        unreachable.  The instruction pointer, if any, is advanced
45846        in the non-relocatable code. */
45847     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n8/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches, 0)
45848 
45849     /* Relocated code will jump to this label in non-relocated code. */
45850   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
45851     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n8/fR*-no-fast-branches non-relocatable code");
45852 #endif // #ifdef JITTER_REPLICATE
45853 #if defined (JITTER_PROFILE_SAMPLE)
45854   JITTER_PROFILE_SAMPLE_UPDATE
45855      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45856       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45857   /* Force the compiler not move sample-profiling instrumentation
45858      beyond this point; this way the actual user code is timed.
45859      This is still not perfect, as residuals are materialised before
45860      we arrive here, but should be adequate at least for slow VM
45861      instructions. */
45862   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
45863 #endif
45864 #if defined (JITTER_PROFILE_COUNT)
45865   /* Notice that, differently from the code above, this
45866      instrumentation code *can* be reordered freely: as long as a
45867      VM instruction is counted, the count increment can be placed
45868      anyehere.  Let GCC move this code and possibly achieve better
45869      throughput by exploiting instruction-level parallelism and
45870      therefore approximate more closely a non-profiled build. */
45871   JITTER_PROFILE_COUNT_UPDATE
45872      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
45873       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
45874 #endif
45875 
45876 /* User-specified code, instruction-beginning-c part: beginning. */
45877 
45878 
45879 /* User-specified code, instruction-beginning-c part: end */
45880 
45881 
45882     /* User code for *check-in-arity--alt/n8/fR*-no-fast-branches . */
45883 
45884     // FIXME: this loops forever with no-threading (not with the other dispatching models
45885     // including minimal threading) when the callee is compiled.  A Jitter bug.
45886     /* Here we can assume that the top object is a closure, without checking: we either
45887        already performed a type check, or the compiler decided it wasn't necessary. */
45888     jitterlisp_object top = JITTER_TOP_MAINSTACK();
45889     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
45890 
45891     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
45892        from the closure compiledness.  [Done] */
45893     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
45894       {
45895         if (c->in_arity != JITTER_ARGN0)
45896           JITTER_BRANCH_FAST(JITTER_ARGF1);
45897       }
45898     else
45899       {
45900         /* The closure is interpreted.  Compute its in-arity.  We can assume that
45901            the formal list is well-formal, which is to say actually a proper list
45902            of distinct symbols. */
45903         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
45904         jitterlisp_object rest = ic->formals;
45905         jitter_uint in_arity = 0;
45906         while (! JITTERLISP_IS_EMPTY_LIST(rest))
45907           {
45908             in_arity ++;
45909             rest = JITTERLISP_EXP_C_A_CDR(rest);
45910           }
45911         if (in_arity != JITTER_ARGN0)
45912           JITTER_BRANCH_FAST(JITTER_ARGF1);
45913       }
45914 
45915     /* End of the user code for *check-in-arity--alt/n8/fR*-no-fast-branches . */
45916 
45917 /* User-specified code, instruction-end-c part: beginning. */
45918 
45919 
45920 /* User-specified code, instruction-end-c part: end */
45921 
45922 #ifdef JITTER_REPLICATE
45923     /* Advance the instruction pointer, if any, to skip residuals;
45924        then jump back to replicated code. */
45925     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
45926     JITTER_SKIP_RESIDUALS_;
45927     goto * _jitter_back_to_replicated_code_pointer;
45928 #endif // #ifdef JITTER_REPLICATE
45929 
45930     /* Undefine the *check-in-arity--alt/n8/fR*-no-fast-branches argument macros so they can't be used
45931        by mistake in the instruction body coming next. */
45932 #   undef JITTER_SLOW_REGISTER_OFFSET0
45933 #   undef JITTER_ARG0
45934 #   undef JITTER_ARGN0
45935 #   undef JITTER_ARGU0
45936 #   undef JITTER_ARGP0
45937 #   undef JITTER_ARGF0
45938 #   undef JITTER_SLOW_REGISTER_OFFSET1
45939 #   undef JITTER_ARG1
45940 #   undef JITTER_ARGN1
45941 #   undef JITTER_ARGU1
45942 #   undef JITTER_ARGP1
45943 #   undef JITTER_ARGF1
45944 
45945 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
45946 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
45947 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
45948 
45949   }
45950 #ifndef JITTER_REPLICATE
45951  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n8/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n8__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
45952 #endif // #ifndef JITTER_REPLICATE
45953 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
45954 
45955   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n9/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches, hot)
45956   {
45957     /* This specialized instruction is a replacement. */
45958 #   undef JITTER_BRANCH_FAST
45959 #   define JITTER_BRANCH_FAST JITTER_BRANCH
45960 #   undef JITTER_BRANCH_FAST_IF_ZERO
45961 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
45962 #   undef JITTER_BRANCH_FAST_IF_NONZERO
45963 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
45964 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
45965 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
45966 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
45967 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
45968 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
45969 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
45970 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
45971 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
45972 #   undef JITTER_BRANCH_FAST_IF_EQUAL
45973 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
45974 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
45975 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
45976 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
45977 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
45978 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
45979 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
45980 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
45981 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
45982 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
45983 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
45984 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
45985 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
45986 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
45987 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
45988 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
45989 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
45990 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
45991 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
45992 #   undef JITTER_BRANCH_FAST_IF_AND
45993 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
45994 #   undef JITTER_BRANCH_FAST_IF_NOTAND
45995 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
45996 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
45997 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
45998 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
45999 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46000 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46001 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46002 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46003 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46004 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46005 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46006 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46007 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46008 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46009 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46010 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46011 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46012 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46013 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46014 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46015 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46016 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46017 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46018 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46019 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46020 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46021 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46022     /* This specialized instruction is non-relocatable.
46023        Its 1-th argument, a literal, is the return address where to jump
46024        at the end, back to relocated code. */
46025 
46026 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       242
46027 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n9/fR*-no-fast-branches
46028 
46029 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches
46030 
46031   /* The residual arity for this instruction does not depend on fast labels. */
46032   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46033 
46034   /* Define argument-access macros for *check-in-arity--alt/n9/fR*-no-fast-branches . */
46035 #ifdef JITTER_HAVE_PATCH_IN
46036   /* Define argument-access macros assuming that fast branches are enabled. */
46037     /* The 0th argument is a nonresidual literal. */
46038 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
46039 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46040 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46041 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46042 
46043     /* The 1th argument is a residual label. */
46044 #if defined(JITTER_DISPATCH_NO_THREADING)
46045 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
46046     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46047 #elif defined (JITTER_REPLICATE)
46048 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
46049 #else
46050 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
46051 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46052 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
46053 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
46054 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
46055 #   define JITTER_ARGF1 JITTER_ARGP1
46056 
46057 #else
46058   /* Define argument-access macros assuming that fast branches are disabled. */
46059     /* The 0th argument is a nonresidual literal. */
46060 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 9L})
46061 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46062 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46063 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46064 #   define JITTER_ARGF0 JITTER_ARGP0
46065 
46066     /* The 1th argument is a residual label. */
46067 #if defined(JITTER_DISPATCH_NO_THREADING)
46068 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
46069     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46070 #elif defined (JITTER_REPLICATE)
46071 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
46072 #else
46073 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
46074 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46075 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
46076 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
46077 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
46078 #   define JITTER_ARGF1 JITTER_ARGP1
46079 
46080 # endif // #ifdef JITTER_HAVE_PATCH_IN
46081 
46082 #ifdef JITTER_REPLICATE
46083     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46084        it on the stack rather than in read-only memory.  I had to do this to prevent
46085        a GCC 8 snapshot on SH from being too clever. */
46086     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46087     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46088        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46089        load the relocated part crashes.
46090                  mov.w     .L1667,r0
46091                  mov.l     @(r0,r15),r1
46092                  jmp       @r1
46093        r15 is the stack pointer.  The constant at .L1667 is
46094           .L1667:
46095                  .short    232
46096        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46097        can't work as an immediate.  Shall I keep these code pointers as a single array?
46098        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46099        but the problem will be the same. */
46100     /* Jump to non-relocatable code. */
46101     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46102 
46103     /* Here the residual arity is given as zero: it's too late to
46104        skip residuals, since we've already jumped and this code is
46105        unreachable.  The instruction pointer, if any, is advanced
46106        in the non-relocatable code. */
46107     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n9/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches, 0)
46108 
46109     /* Relocated code will jump to this label in non-relocated code. */
46110   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46111     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n9/fR*-no-fast-branches non-relocatable code");
46112 #endif // #ifdef JITTER_REPLICATE
46113 #if defined (JITTER_PROFILE_SAMPLE)
46114   JITTER_PROFILE_SAMPLE_UPDATE
46115      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46116       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46117   /* Force the compiler not move sample-profiling instrumentation
46118      beyond this point; this way the actual user code is timed.
46119      This is still not perfect, as residuals are materialised before
46120      we arrive here, but should be adequate at least for slow VM
46121      instructions. */
46122   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46123 #endif
46124 #if defined (JITTER_PROFILE_COUNT)
46125   /* Notice that, differently from the code above, this
46126      instrumentation code *can* be reordered freely: as long as a
46127      VM instruction is counted, the count increment can be placed
46128      anyehere.  Let GCC move this code and possibly achieve better
46129      throughput by exploiting instruction-level parallelism and
46130      therefore approximate more closely a non-profiled build. */
46131   JITTER_PROFILE_COUNT_UPDATE
46132      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46133       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46134 #endif
46135 
46136 /* User-specified code, instruction-beginning-c part: beginning. */
46137 
46138 
46139 /* User-specified code, instruction-beginning-c part: end */
46140 
46141 
46142     /* User code for *check-in-arity--alt/n9/fR*-no-fast-branches . */
46143 
46144     // FIXME: this loops forever with no-threading (not with the other dispatching models
46145     // including minimal threading) when the callee is compiled.  A Jitter bug.
46146     /* Here we can assume that the top object is a closure, without checking: we either
46147        already performed a type check, or the compiler decided it wasn't necessary. */
46148     jitterlisp_object top = JITTER_TOP_MAINSTACK();
46149     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
46150 
46151     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
46152        from the closure compiledness.  [Done] */
46153     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
46154       {
46155         if (c->in_arity != JITTER_ARGN0)
46156           JITTER_BRANCH_FAST(JITTER_ARGF1);
46157       }
46158     else
46159       {
46160         /* The closure is interpreted.  Compute its in-arity.  We can assume that
46161            the formal list is well-formal, which is to say actually a proper list
46162            of distinct symbols. */
46163         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
46164         jitterlisp_object rest = ic->formals;
46165         jitter_uint in_arity = 0;
46166         while (! JITTERLISP_IS_EMPTY_LIST(rest))
46167           {
46168             in_arity ++;
46169             rest = JITTERLISP_EXP_C_A_CDR(rest);
46170           }
46171         if (in_arity != JITTER_ARGN0)
46172           JITTER_BRANCH_FAST(JITTER_ARGF1);
46173       }
46174 
46175     /* End of the user code for *check-in-arity--alt/n9/fR*-no-fast-branches . */
46176 
46177 /* User-specified code, instruction-end-c part: beginning. */
46178 
46179 
46180 /* User-specified code, instruction-end-c part: end */
46181 
46182 #ifdef JITTER_REPLICATE
46183     /* Advance the instruction pointer, if any, to skip residuals;
46184        then jump back to replicated code. */
46185     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
46186     JITTER_SKIP_RESIDUALS_;
46187     goto * _jitter_back_to_replicated_code_pointer;
46188 #endif // #ifdef JITTER_REPLICATE
46189 
46190     /* Undefine the *check-in-arity--alt/n9/fR*-no-fast-branches argument macros so they can't be used
46191        by mistake in the instruction body coming next. */
46192 #   undef JITTER_SLOW_REGISTER_OFFSET0
46193 #   undef JITTER_ARG0
46194 #   undef JITTER_ARGN0
46195 #   undef JITTER_ARGU0
46196 #   undef JITTER_ARGP0
46197 #   undef JITTER_ARGF0
46198 #   undef JITTER_SLOW_REGISTER_OFFSET1
46199 #   undef JITTER_ARG1
46200 #   undef JITTER_ARGN1
46201 #   undef JITTER_ARGU1
46202 #   undef JITTER_ARGP1
46203 #   undef JITTER_ARGF1
46204 
46205 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46206 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46207 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46208 
46209   }
46210 #ifndef JITTER_REPLICATE
46211  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n9/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n9__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46212 #endif // #ifndef JITTER_REPLICATE
46213 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46214 
46215   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/n10/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches, hot)
46216   {
46217     /* This specialized instruction is a replacement. */
46218 #   undef JITTER_BRANCH_FAST
46219 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46220 #   undef JITTER_BRANCH_FAST_IF_ZERO
46221 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46222 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46223 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46224 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46225 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46226 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46227 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46228 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46229 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46230 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46231 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46232 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46233 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46234 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46235 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46236 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46237 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46238 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46239 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46240 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46241 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46242 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46243 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46244 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46245 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46246 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46247 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46248 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46249 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46250 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46251 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46252 #   undef JITTER_BRANCH_FAST_IF_AND
46253 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46254 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46255 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46256 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46257 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46258 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46259 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46260 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46261 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46262 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46263 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46264 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46265 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46266 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46267 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46268 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46269 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46270 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46271 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46272 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46273 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46274 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46275 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46276 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46277 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46278 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46279 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46280 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46281 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46282     /* This specialized instruction is non-relocatable.
46283        Its 1-th argument, a literal, is the return address where to jump
46284        at the end, back to relocated code. */
46285 
46286 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       243
46287 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/n10/fR*-no-fast-branches
46288 
46289 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches
46290 
46291   /* The residual arity for this instruction does not depend on fast labels. */
46292   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46293 
46294   /* Define argument-access macros for *check-in-arity--alt/n10/fR*-no-fast-branches . */
46295 #ifdef JITTER_HAVE_PATCH_IN
46296   /* Define argument-access macros assuming that fast branches are enabled. */
46297     /* The 0th argument is a nonresidual literal. */
46298 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
46299 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46300 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46301 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46302 
46303     /* The 1th argument is a residual label. */
46304 #if defined(JITTER_DISPATCH_NO_THREADING)
46305 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
46306     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46307 #elif defined (JITTER_REPLICATE)
46308 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
46309 #else
46310 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
46311 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46312 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
46313 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
46314 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
46315 #   define JITTER_ARGF1 JITTER_ARGP1
46316 
46317 #else
46318   /* Define argument-access macros assuming that fast branches are disabled. */
46319     /* The 0th argument is a nonresidual literal. */
46320 #   define JITTER_ARG0  ((const union jitter_word){.fixnum = 10L})
46321 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46322 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46323 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46324 #   define JITTER_ARGF0 JITTER_ARGP0
46325 
46326     /* The 1th argument is a residual label. */
46327 #if defined(JITTER_DISPATCH_NO_THREADING)
46328 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_0
46329     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46330 #elif defined (JITTER_REPLICATE)
46331 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[0])
46332 #else
46333 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
46334 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46335 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
46336 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
46337 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
46338 #   define JITTER_ARGF1 JITTER_ARGP1
46339 
46340 # endif // #ifdef JITTER_HAVE_PATCH_IN
46341 
46342 #ifdef JITTER_REPLICATE
46343     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46344        it on the stack rather than in read-only memory.  I had to do this to prevent
46345        a GCC 8 snapshot on SH from being too clever. */
46346     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46347     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46348        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46349        load the relocated part crashes.
46350                  mov.w     .L1667,r0
46351                  mov.l     @(r0,r15),r1
46352                  jmp       @r1
46353        r15 is the stack pointer.  The constant at .L1667 is
46354           .L1667:
46355                  .short    232
46356        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46357        can't work as an immediate.  Shall I keep these code pointers as a single array?
46358        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46359        but the problem will be the same. */
46360     /* Jump to non-relocatable code. */
46361     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46362 
46363     /* Here the residual arity is given as zero: it's too late to
46364        skip residuals, since we've already jumped and this code is
46365        unreachable.  The instruction pointer, if any, is advanced
46366        in the non-relocatable code. */
46367     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n10/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches, 0)
46368 
46369     /* Relocated code will jump to this label in non-relocated code. */
46370   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46371     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/n10/fR*-no-fast-branches non-relocatable code");
46372 #endif // #ifdef JITTER_REPLICATE
46373 #if defined (JITTER_PROFILE_SAMPLE)
46374   JITTER_PROFILE_SAMPLE_UPDATE
46375      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46376       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46377   /* Force the compiler not move sample-profiling instrumentation
46378      beyond this point; this way the actual user code is timed.
46379      This is still not perfect, as residuals are materialised before
46380      we arrive here, but should be adequate at least for slow VM
46381      instructions. */
46382   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46383 #endif
46384 #if defined (JITTER_PROFILE_COUNT)
46385   /* Notice that, differently from the code above, this
46386      instrumentation code *can* be reordered freely: as long as a
46387      VM instruction is counted, the count increment can be placed
46388      anyehere.  Let GCC move this code and possibly achieve better
46389      throughput by exploiting instruction-level parallelism and
46390      therefore approximate more closely a non-profiled build. */
46391   JITTER_PROFILE_COUNT_UPDATE
46392      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46393       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46394 #endif
46395 
46396 /* User-specified code, instruction-beginning-c part: beginning. */
46397 
46398 
46399 /* User-specified code, instruction-beginning-c part: end */
46400 
46401 
46402     /* User code for *check-in-arity--alt/n10/fR*-no-fast-branches . */
46403 
46404     // FIXME: this loops forever with no-threading (not with the other dispatching models
46405     // including minimal threading) when the callee is compiled.  A Jitter bug.
46406     /* Here we can assume that the top object is a closure, without checking: we either
46407        already performed a type check, or the compiler decided it wasn't necessary. */
46408     jitterlisp_object top = JITTER_TOP_MAINSTACK();
46409     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
46410 
46411     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
46412        from the closure compiledness.  [Done] */
46413     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
46414       {
46415         if (c->in_arity != JITTER_ARGN0)
46416           JITTER_BRANCH_FAST(JITTER_ARGF1);
46417       }
46418     else
46419       {
46420         /* The closure is interpreted.  Compute its in-arity.  We can assume that
46421            the formal list is well-formal, which is to say actually a proper list
46422            of distinct symbols. */
46423         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
46424         jitterlisp_object rest = ic->formals;
46425         jitter_uint in_arity = 0;
46426         while (! JITTERLISP_IS_EMPTY_LIST(rest))
46427           {
46428             in_arity ++;
46429             rest = JITTERLISP_EXP_C_A_CDR(rest);
46430           }
46431         if (in_arity != JITTER_ARGN0)
46432           JITTER_BRANCH_FAST(JITTER_ARGF1);
46433       }
46434 
46435     /* End of the user code for *check-in-arity--alt/n10/fR*-no-fast-branches . */
46436 
46437 /* User-specified code, instruction-end-c part: beginning. */
46438 
46439 
46440 /* User-specified code, instruction-end-c part: end */
46441 
46442 #ifdef JITTER_REPLICATE
46443     /* Advance the instruction pointer, if any, to skip residuals;
46444        then jump back to replicated code. */
46445     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
46446     JITTER_SKIP_RESIDUALS_;
46447     goto * _jitter_back_to_replicated_code_pointer;
46448 #endif // #ifdef JITTER_REPLICATE
46449 
46450     /* Undefine the *check-in-arity--alt/n10/fR*-no-fast-branches argument macros so they can't be used
46451        by mistake in the instruction body coming next. */
46452 #   undef JITTER_SLOW_REGISTER_OFFSET0
46453 #   undef JITTER_ARG0
46454 #   undef JITTER_ARGN0
46455 #   undef JITTER_ARGU0
46456 #   undef JITTER_ARGP0
46457 #   undef JITTER_ARGF0
46458 #   undef JITTER_SLOW_REGISTER_OFFSET1
46459 #   undef JITTER_ARG1
46460 #   undef JITTER_ARGN1
46461 #   undef JITTER_ARGU1
46462 #   undef JITTER_ARGP1
46463 #   undef JITTER_ARGF1
46464 
46465 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46466 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46467 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46468 
46469   }
46470 #ifndef JITTER_REPLICATE
46471  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/n10/fR*-no-fast-branches, _Acheck_min_marity_m_malt__n10__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46472 #endif // #ifndef JITTER_REPLICATE
46473 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46474 
46475   JITTER_INSTRUCTION_PROLOG_(*check-in-arity--alt/nR/fR*-no-fast-branches, _Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches, cold)
46476   {
46477     /* This specialized instruction is a replacement. */
46478 #   undef JITTER_BRANCH_FAST
46479 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46480 #   undef JITTER_BRANCH_FAST_IF_ZERO
46481 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46482 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46483 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46484 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46485 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46486 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46487 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46488 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46489 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46490 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46491 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46492 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46493 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46494 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46495 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46496 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46497 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46498 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46499 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46500 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46501 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46502 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46503 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46504 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46505 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46506 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46507 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46508 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46509 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46510 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46511 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46512 #   undef JITTER_BRANCH_FAST_IF_AND
46513 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46514 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46515 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46516 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46517 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46518 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46519 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46520 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46521 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46522 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46523 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46524 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46525 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46526 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46527 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46528 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46529 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46530 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46531 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46532 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46533 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46534 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46535 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46536 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46537 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46538 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46539 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46540 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46541 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46542     /* This specialized instruction is non-relocatable.
46543        Its 1-th argument, a literal, is the return address where to jump
46544        at the end, back to relocated code. */
46545 
46546 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       244
46547 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *check-in-arity--alt/nR/fR*-no-fast-branches
46548 
46549 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches
46550 
46551   /* The residual arity for this instruction does not depend on fast labels. */
46552   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
46553 
46554   /* Define argument-access macros for *check-in-arity--alt/nR/fR*-no-fast-branches . */
46555 #ifdef JITTER_HAVE_PATCH_IN
46556   /* Define argument-access macros assuming that fast branches are enabled. */
46557     /* The 0th argument is a residual literal. */
46558 #if defined(JITTER_DISPATCH_NO_THREADING)
46559 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46560     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46561 #elif defined (JITTER_REPLICATE)
46562 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46563 #else
46564 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46565 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46566 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46567 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46568 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46569 
46570     /* The 1th argument is a residual label. */
46571 #if defined(JITTER_DISPATCH_NO_THREADING)
46572 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
46573     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
46574 #elif defined (JITTER_REPLICATE)
46575 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
46576 #else
46577 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
46578 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46579 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
46580 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
46581 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
46582 #   define JITTER_ARGF1 JITTER_ARGP1
46583 
46584 #else
46585   /* Define argument-access macros assuming that fast branches are disabled. */
46586     /* The 0th argument is a residual literal. */
46587 #if defined(JITTER_DISPATCH_NO_THREADING)
46588 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46589     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46590 #elif defined (JITTER_REPLICATE)
46591 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46592 #else
46593 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46594 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46595 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46596 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46597 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46598 #   define JITTER_ARGF0 JITTER_ARGP0
46599 
46600     /* The 1th argument is a residual label. */
46601 #if defined(JITTER_DISPATCH_NO_THREADING)
46602 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
46603     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
46604 #elif defined (JITTER_REPLICATE)
46605 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
46606 #else
46607 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
46608 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46609 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
46610 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
46611 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
46612 #   define JITTER_ARGF1 JITTER_ARGP1
46613 
46614 # endif // #ifdef JITTER_HAVE_PATCH_IN
46615 
46616 #ifdef JITTER_REPLICATE
46617     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46618        it on the stack rather than in read-only memory.  I had to do this to prevent
46619        a GCC 8 snapshot on SH from being too clever. */
46620     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46621     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46622        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46623        load the relocated part crashes.
46624                  mov.w     .L1667,r0
46625                  mov.l     @(r0,r15),r1
46626                  jmp       @r1
46627        r15 is the stack pointer.  The constant at .L1667 is
46628           .L1667:
46629                  .short    232
46630        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46631        can't work as an immediate.  Shall I keep these code pointers as a single array?
46632        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46633        but the problem will be the same. */
46634     /* Jump to non-relocatable code. */
46635     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46636 
46637     /* Here the residual arity is given as zero: it's too late to
46638        skip residuals, since we've already jumped and this code is
46639        unreachable.  The instruction pointer, if any, is advanced
46640        in the non-relocatable code. */
46641     JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/nR/fR*-no-fast-branches, _Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches, 0)
46642 
46643     /* Relocated code will jump to this label in non-relocated code. */
46644   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46645     JITTER_COMMENT_IN_ASM_("*check-in-arity--alt/nR/fR*-no-fast-branches non-relocatable code");
46646 #endif // #ifdef JITTER_REPLICATE
46647 #if defined (JITTER_PROFILE_SAMPLE)
46648   JITTER_PROFILE_SAMPLE_UPDATE
46649      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46650       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46651   /* Force the compiler not move sample-profiling instrumentation
46652      beyond this point; this way the actual user code is timed.
46653      This is still not perfect, as residuals are materialised before
46654      we arrive here, but should be adequate at least for slow VM
46655      instructions. */
46656   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46657 #endif
46658 #if defined (JITTER_PROFILE_COUNT)
46659   /* Notice that, differently from the code above, this
46660      instrumentation code *can* be reordered freely: as long as a
46661      VM instruction is counted, the count increment can be placed
46662      anyehere.  Let GCC move this code and possibly achieve better
46663      throughput by exploiting instruction-level parallelism and
46664      therefore approximate more closely a non-profiled build. */
46665   JITTER_PROFILE_COUNT_UPDATE
46666      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46667       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46668 #endif
46669 
46670 /* User-specified code, instruction-beginning-c part: beginning. */
46671 
46672 
46673 /* User-specified code, instruction-beginning-c part: end */
46674 
46675 
46676     /* User code for *check-in-arity--alt/nR/fR*-no-fast-branches . */
46677 
46678     // FIXME: this loops forever with no-threading (not with the other dispatching models
46679     // including minimal threading) when the callee is compiled.  A Jitter bug.
46680     /* Here we can assume that the top object is a closure, without checking: we either
46681        already performed a type check, or the compiler decided it wasn't necessary. */
46682     jitterlisp_object top = JITTER_TOP_MAINSTACK();
46683     struct jitterlisp_closure *c = JITTERLISP_CLOSURE_DECODE(top);
46684 
46685     /* FIXME: this is optimizable.  I should store the in-arity as a field, independently
46686        from the closure compiledness.  [Done] */
46687     if (JITTERLISP_IS_COMPILED_CLOSURE(top))
46688       {
46689         if (c->in_arity != JITTER_ARGN0)
46690           JITTER_BRANCH_FAST(JITTER_ARGF1);
46691       }
46692     else
46693       {
46694         /* The closure is interpreted.  Compute its in-arity.  We can assume that
46695            the formal list is well-formal, which is to say actually a proper list
46696            of distinct symbols. */
46697         struct jitterlisp_interpreted_closure *ic = & c->interpreted;
46698         jitterlisp_object rest = ic->formals;
46699         jitter_uint in_arity = 0;
46700         while (! JITTERLISP_IS_EMPTY_LIST(rest))
46701           {
46702             in_arity ++;
46703             rest = JITTERLISP_EXP_C_A_CDR(rest);
46704           }
46705         if (in_arity != JITTER_ARGN0)
46706           JITTER_BRANCH_FAST(JITTER_ARGF1);
46707       }
46708 
46709     /* End of the user code for *check-in-arity--alt/nR/fR*-no-fast-branches . */
46710 
46711 /* User-specified code, instruction-end-c part: beginning. */
46712 
46713 
46714 /* User-specified code, instruction-end-c part: end */
46715 
46716 #ifdef JITTER_REPLICATE
46717     /* Advance the instruction pointer, if any, to skip residuals;
46718        then jump back to replicated code. */
46719     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
46720     JITTER_SKIP_RESIDUALS_;
46721     goto * _jitter_back_to_replicated_code_pointer;
46722 #endif // #ifdef JITTER_REPLICATE
46723 
46724     /* Undefine the *check-in-arity--alt/nR/fR*-no-fast-branches argument macros so they can't be used
46725        by mistake in the instruction body coming next. */
46726 #   undef JITTER_SLOW_REGISTER_OFFSET0
46727 #   undef JITTER_ARG0
46728 #   undef JITTER_ARGN0
46729 #   undef JITTER_ARGU0
46730 #   undef JITTER_ARGP0
46731 #   undef JITTER_ARGF0
46732 #   undef JITTER_SLOW_REGISTER_OFFSET1
46733 #   undef JITTER_ARG1
46734 #   undef JITTER_ARGN1
46735 #   undef JITTER_ARGU1
46736 #   undef JITTER_ARGP1
46737 #   undef JITTER_ARGF1
46738 
46739 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46740 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46741 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46742 
46743   }
46744 #ifndef JITTER_REPLICATE
46745  JITTER_INSTRUCTION_EPILOG_(*check-in-arity--alt/nR/fR*-no-fast-branches, _Acheck_min_marity_m_malt__nR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46746 #endif // #ifndef JITTER_REPLICATE
46747 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46748 
46749   JITTER_INSTRUCTION_PROLOG_(*gc-if-needed/fR*-no-fast-branches, _Agc_mif_mneeded__fR_A_mno_mfast_mbranches, hot)
46750   {
46751     /* This specialized instruction is a replacement. */
46752 #   undef JITTER_BRANCH_FAST
46753 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46754 #   undef JITTER_BRANCH_FAST_IF_ZERO
46755 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46756 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46757 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46758 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46759 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46760 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46761 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46762 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46763 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46764 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46765 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46766 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46767 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46768 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
46769 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
46770 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
46771 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
46772 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
46773 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
46774 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
46775 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
46776 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46777 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
46778 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
46779 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
46780 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
46781 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
46782 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
46783 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
46784 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
46785 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
46786 #   undef JITTER_BRANCH_FAST_IF_AND
46787 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
46788 #   undef JITTER_BRANCH_FAST_IF_NOTAND
46789 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
46790 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
46791 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
46792 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
46793 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
46794 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
46795 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
46796 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
46797 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
46798 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
46799 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
46800 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
46801 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
46802 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
46803 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
46804 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
46805 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
46806 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
46807 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
46808 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
46809 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
46810 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
46811 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
46812 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
46813 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
46814 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
46815 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
46816     /* This specialized instruction is non-relocatable.
46817        Its 0-th argument, a literal, is the return address where to jump
46818        at the end, back to relocated code. */
46819 
46820 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       245
46821 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *gc-if-needed/fR*-no-fast-branches
46822 
46823 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Agc_mif_mneeded__fR_A_mno_mfast_mbranches
46824 
46825   /* The residual arity for this instruction does not depend on fast labels. */
46826   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
46827 
46828   /* Define argument-access macros for *gc-if-needed/fR*-no-fast-branches . */
46829 #ifdef JITTER_HAVE_PATCH_IN
46830   /* Define argument-access macros assuming that fast branches are enabled. */
46831     /* The 0th argument is a residual label. */
46832 #if defined(JITTER_DISPATCH_NO_THREADING)
46833 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46834     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46835 #elif defined (JITTER_REPLICATE)
46836 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46837 #else
46838 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46839 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46840 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46841 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46842 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46843 #   define JITTER_ARGF0 JITTER_ARGP0
46844 
46845 #else
46846   /* Define argument-access macros assuming that fast branches are disabled. */
46847     /* The 0th argument is a residual label. */
46848 #if defined(JITTER_DISPATCH_NO_THREADING)
46849 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
46850     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
46851 #elif defined (JITTER_REPLICATE)
46852 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
46853 #else
46854 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
46855 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
46856 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
46857 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
46858 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
46859 #   define JITTER_ARGF0 JITTER_ARGP0
46860 
46861 # endif // #ifdef JITTER_HAVE_PATCH_IN
46862 
46863 #ifdef JITTER_REPLICATE
46864     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
46865        it on the stack rather than in read-only memory.  I had to do this to prevent
46866        a GCC 8 snapshot on SH from being too clever. */
46867     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46868     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
46869        in memory, as a 16-bit constant; and since it reads it with a PC-relative
46870        load the relocated part crashes.
46871                  mov.w     .L1667,r0
46872                  mov.l     @(r0,r15),r1
46873                  jmp       @r1
46874        r15 is the stack pointer.  The constant at .L1667 is
46875           .L1667:
46876                  .short    232
46877        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
46878        can't work as an immediate.  Shall I keep these code pointers as a single array?
46879        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
46880        but the problem will be the same. */
46881     /* Jump to non-relocatable code. */
46882     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
46883 
46884     /* Here the residual arity is given as zero: it's too late to
46885        skip residuals, since we've already jumped and this code is
46886        unreachable.  The instruction pointer, if any, is advanced
46887        in the non-relocatable code. */
46888     JITTER_INSTRUCTION_EPILOG_(*gc-if-needed/fR*-no-fast-branches, _Agc_mif_mneeded__fR_A_mno_mfast_mbranches, 0)
46889 
46890     /* Relocated code will jump to this label in non-relocated code. */
46891   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
46892     JITTER_COMMENT_IN_ASM_("*gc-if-needed/fR*-no-fast-branches non-relocatable code");
46893 #endif // #ifdef JITTER_REPLICATE
46894 #if defined (JITTER_PROFILE_SAMPLE)
46895   JITTER_PROFILE_SAMPLE_UPDATE
46896      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46897       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46898   /* Force the compiler not move sample-profiling instrumentation
46899      beyond this point; this way the actual user code is timed.
46900      This is still not perfect, as residuals are materialised before
46901      we arrive here, but should be adequate at least for slow VM
46902      instructions. */
46903   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
46904 #endif
46905 #if defined (JITTER_PROFILE_COUNT)
46906   /* Notice that, differently from the code above, this
46907      instrumentation code *can* be reordered freely: as long as a
46908      VM instruction is counted, the count increment can be placed
46909      anyehere.  Let GCC move this code and possibly achieve better
46910      throughput by exploiting instruction-level parallelism and
46911      therefore approximate more closely a non-profiled build. */
46912   JITTER_PROFILE_COUNT_UPDATE
46913      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
46914       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
46915 #endif
46916 
46917 /* User-specified code, instruction-beginning-c part: beginning. */
46918 
46919 
46920 /* User-specified code, instruction-beginning-c part: end */
46921 
46922 
46923     /* User code for *gc-if-needed/fR*-no-fast-branches . */
46924 
46925 #ifdef JITTER_GC_STUB
46926     /* FIXME: I might want to merge this, along with the body of other
46927        instructions, into a macro.  This may still be factored in a different
46928        way, but the idea looks correct and promising. */
46929     /* Branch to the slow path of the allocation, which includes a minor GC,
46930        in case the allocation pointer is now out of the nursery.  Do nothing
46931        otherwise.
46932        Rationale: separating branches from instructions having effect on the VM
46933        state prevents defective instructions; even if I have reason to believe
46934        that this particular state effect (unconditionally incrementing a runtime
46935        field) is not problematic with respect to defects, I will need to seriously
46936        stress the system after defect replacement is really implemented. */
46937     JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
46938        (JITTER_STATE_RUNTIME_FIELD (allocation_next),
46939         JITTER_STATE_RUNTIME_FIELD (allocation_limit),
46940         JITTER_ARGF0);
46941 #else
46942     /* Nothing to do.  With the ordinary non-stub heap all the actual
46943        memory allocation happens in primitive-cons-special. */
46944 #endif //#ifdef JITTER_GC_STUB
46945 
46946     /* End of the user code for *gc-if-needed/fR*-no-fast-branches . */
46947 
46948 /* User-specified code, instruction-end-c part: beginning. */
46949 
46950 
46951 /* User-specified code, instruction-end-c part: end */
46952 
46953 #ifdef JITTER_REPLICATE
46954     /* Advance the instruction pointer, if any, to skip residuals;
46955        then jump back to replicated code. */
46956     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
46957     JITTER_SKIP_RESIDUALS_;
46958     goto * _jitter_back_to_replicated_code_pointer;
46959 #endif // #ifdef JITTER_REPLICATE
46960 
46961     /* Undefine the *gc-if-needed/fR*-no-fast-branches argument macros so they can't be used
46962        by mistake in the instruction body coming next. */
46963 #   undef JITTER_SLOW_REGISTER_OFFSET0
46964 #   undef JITTER_ARG0
46965 #   undef JITTER_ARGN0
46966 #   undef JITTER_ARGU0
46967 #   undef JITTER_ARGP0
46968 #   undef JITTER_ARGF0
46969 
46970 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
46971 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
46972 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
46973 
46974   }
46975 #ifndef JITTER_REPLICATE
46976  JITTER_INSTRUCTION_EPILOG_(*gc-if-needed/fR*-no-fast-branches, _Agc_mif_mneeded__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
46977 #endif // #ifndef JITTER_REPLICATE
46978 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
46979 
46980   JITTER_INSTRUCTION_PROLOG_(*pop-to-global/nR/fR*-no-fast-branches, _Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches, cold)
46981   {
46982     /* This specialized instruction is a replacement. */
46983 #   undef JITTER_BRANCH_FAST
46984 #   define JITTER_BRANCH_FAST JITTER_BRANCH
46985 #   undef JITTER_BRANCH_FAST_IF_ZERO
46986 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
46987 #   undef JITTER_BRANCH_FAST_IF_NONZERO
46988 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
46989 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
46990 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
46991 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
46992 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
46993 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
46994 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
46995 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
46996 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
46997 #   undef JITTER_BRANCH_FAST_IF_EQUAL
46998 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
46999 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47000 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47001 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47002 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47003 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47004 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47005 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47006 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47007 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47008 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47009 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47010 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47011 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47012 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47013 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47014 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47015 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47016 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47017 #   undef JITTER_BRANCH_FAST_IF_AND
47018 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47019 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47020 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47021 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47022 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47023 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47024 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47025 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47026 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47027 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47028 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47029 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47030 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47031 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47032 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47033 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47034 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47035 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47036 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47037 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47038 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47039 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47040 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47041 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47042 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47043 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47044 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47045 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47046 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47047     /* This specialized instruction is non-relocatable.
47048        Its 1-th argument, a literal, is the return address where to jump
47049        at the end, back to relocated code. */
47050 
47051 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       246
47052 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *pop-to-global/nR/fR*-no-fast-branches
47053 
47054 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches
47055 
47056   /* The residual arity for this instruction does not depend on fast labels. */
47057   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
47058 
47059   /* Define argument-access macros for *pop-to-global/nR/fR*-no-fast-branches . */
47060 #ifdef JITTER_HAVE_PATCH_IN
47061   /* Define argument-access macros assuming that fast branches are enabled. */
47062     /* The 0th argument is a residual literal. */
47063 #if defined(JITTER_DISPATCH_NO_THREADING)
47064 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47065     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47066 #elif defined (JITTER_REPLICATE)
47067 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47068 #else
47069 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47070 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47071 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47072 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47073 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47074 
47075     /* The 1th argument is a residual label. */
47076 #if defined(JITTER_DISPATCH_NO_THREADING)
47077 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
47078     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47079 #elif defined (JITTER_REPLICATE)
47080 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
47081 #else
47082 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
47083 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47084 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47085 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47086 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47087 #   define JITTER_ARGF1 JITTER_ARGP1
47088 
47089 #else
47090   /* Define argument-access macros assuming that fast branches are disabled. */
47091     /* The 0th argument is a residual literal. */
47092 #if defined(JITTER_DISPATCH_NO_THREADING)
47093 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47094     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47095 #elif defined (JITTER_REPLICATE)
47096 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47097 #else
47098 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47099 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47100 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47101 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47102 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47103 #   define JITTER_ARGF0 JITTER_ARGP0
47104 
47105     /* The 1th argument is a residual label. */
47106 #if defined(JITTER_DISPATCH_NO_THREADING)
47107 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
47108     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47109 #elif defined (JITTER_REPLICATE)
47110 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
47111 #else
47112 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
47113 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47114 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47115 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47116 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47117 #   define JITTER_ARGF1 JITTER_ARGP1
47118 
47119 # endif // #ifdef JITTER_HAVE_PATCH_IN
47120 
47121 #ifdef JITTER_REPLICATE
47122     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47123        it on the stack rather than in read-only memory.  I had to do this to prevent
47124        a GCC 8 snapshot on SH from being too clever. */
47125     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47126     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47127        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47128        load the relocated part crashes.
47129                  mov.w     .L1667,r0
47130                  mov.l     @(r0,r15),r1
47131                  jmp       @r1
47132        r15 is the stack pointer.  The constant at .L1667 is
47133           .L1667:
47134                  .short    232
47135        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47136        can't work as an immediate.  Shall I keep these code pointers as a single array?
47137        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47138        but the problem will be the same. */
47139     /* Jump to non-relocatable code. */
47140     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47141 
47142     /* Here the residual arity is given as zero: it's too late to
47143        skip residuals, since we've already jumped and this code is
47144        unreachable.  The instruction pointer, if any, is advanced
47145        in the non-relocatable code. */
47146     JITTER_INSTRUCTION_EPILOG_(*pop-to-global/nR/fR*-no-fast-branches, _Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches, 0)
47147 
47148     /* Relocated code will jump to this label in non-relocated code. */
47149   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47150     JITTER_COMMENT_IN_ASM_("*pop-to-global/nR/fR*-no-fast-branches non-relocatable code");
47151 #endif // #ifdef JITTER_REPLICATE
47152 #if defined (JITTER_PROFILE_SAMPLE)
47153   JITTER_PROFILE_SAMPLE_UPDATE
47154      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47155       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47156   /* Force the compiler not move sample-profiling instrumentation
47157      beyond this point; this way the actual user code is timed.
47158      This is still not perfect, as residuals are materialised before
47159      we arrive here, but should be adequate at least for slow VM
47160      instructions. */
47161   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47162 #endif
47163 #if defined (JITTER_PROFILE_COUNT)
47164   /* Notice that, differently from the code above, this
47165      instrumentation code *can* be reordered freely: as long as a
47166      VM instruction is counted, the count increment can be placed
47167      anyehere.  Let GCC move this code and possibly achieve better
47168      throughput by exploiting instruction-level parallelism and
47169      therefore approximate more closely a non-profiled build. */
47170   JITTER_PROFILE_COUNT_UPDATE
47171      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47172       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47173 #endif
47174 
47175 /* User-specified code, instruction-beginning-c part: beginning. */
47176 
47177 
47178 /* User-specified code, instruction-beginning-c part: end */
47179 
47180 
47181     /* User code for *pop-to-global/nR/fR*-no-fast-branches . */
47182 
47183     jitterlisp_object tagged_symbol = JITTER_ARGN0;
47184     struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
47185 #ifndef JITTERLISP_UNSAFE
47186     JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
47187 #endif // #ifndef JITTERLISP_UNSAFE
47188     symbol->global_value = JITTER_TOP_MAINSTACK();
47189     JITTER_DROP_MAINSTACK();
47190 
47191     /* End of the user code for *pop-to-global/nR/fR*-no-fast-branches . */
47192 
47193 /* User-specified code, instruction-end-c part: beginning. */
47194 
47195 
47196 /* User-specified code, instruction-end-c part: end */
47197 
47198 #ifdef JITTER_REPLICATE
47199     /* Advance the instruction pointer, if any, to skip residuals;
47200        then jump back to replicated code. */
47201     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
47202     JITTER_SKIP_RESIDUALS_;
47203     goto * _jitter_back_to_replicated_code_pointer;
47204 #endif // #ifdef JITTER_REPLICATE
47205 
47206     /* Undefine the *pop-to-global/nR/fR*-no-fast-branches argument macros so they can't be used
47207        by mistake in the instruction body coming next. */
47208 #   undef JITTER_SLOW_REGISTER_OFFSET0
47209 #   undef JITTER_ARG0
47210 #   undef JITTER_ARGN0
47211 #   undef JITTER_ARGU0
47212 #   undef JITTER_ARGP0
47213 #   undef JITTER_ARGF0
47214 #   undef JITTER_SLOW_REGISTER_OFFSET1
47215 #   undef JITTER_ARG1
47216 #   undef JITTER_ARGN1
47217 #   undef JITTER_ARGU1
47218 #   undef JITTER_ARGP1
47219 #   undef JITTER_ARGF1
47220 
47221 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47222 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47223 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47224 
47225   }
47226 #ifndef JITTER_REPLICATE
47227  JITTER_INSTRUCTION_EPILOG_(*pop-to-global/nR/fR*-no-fast-branches, _Apop_mto_mglobal__nR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47228 #endif // #ifndef JITTER_REPLICATE
47229 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47230 
47231   JITTER_INSTRUCTION_PROLOG_(*pop-to-global-defined/nR/fR*-no-fast-branches, _Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches, cold)
47232   {
47233     /* This specialized instruction is a replacement. */
47234 #   undef JITTER_BRANCH_FAST
47235 #   define JITTER_BRANCH_FAST JITTER_BRANCH
47236 #   undef JITTER_BRANCH_FAST_IF_ZERO
47237 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
47238 #   undef JITTER_BRANCH_FAST_IF_NONZERO
47239 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
47240 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
47241 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
47242 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
47243 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
47244 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
47245 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
47246 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
47247 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
47248 #   undef JITTER_BRANCH_FAST_IF_EQUAL
47249 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
47250 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47251 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47252 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47253 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47254 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47255 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47256 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47257 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47258 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47259 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47260 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47261 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47262 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47263 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47264 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47265 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47266 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47267 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47268 #   undef JITTER_BRANCH_FAST_IF_AND
47269 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47270 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47271 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47272 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47273 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47274 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47275 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47276 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47277 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47278 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47279 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47280 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47281 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47282 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47283 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47284 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47285 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47286 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47287 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47288 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47289 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47290 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47291 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47292 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47293 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47294 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47295 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47296 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47297 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47298     /* This specialized instruction is non-relocatable.
47299        Its 1-th argument, a literal, is the return address where to jump
47300        at the end, back to relocated code. */
47301 
47302 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       247
47303 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *pop-to-global-defined/nR/fR*-no-fast-branches
47304 
47305 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches
47306 
47307   /* The residual arity for this instruction does not depend on fast labels. */
47308   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
47309 
47310   /* Define argument-access macros for *pop-to-global-defined/nR/fR*-no-fast-branches . */
47311 #ifdef JITTER_HAVE_PATCH_IN
47312   /* Define argument-access macros assuming that fast branches are enabled. */
47313     /* The 0th argument is a residual literal. */
47314 #if defined(JITTER_DISPATCH_NO_THREADING)
47315 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47316     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47317 #elif defined (JITTER_REPLICATE)
47318 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47319 #else
47320 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47321 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47322 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47323 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47324 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47325 
47326     /* The 1th argument is a residual label. */
47327 #if defined(JITTER_DISPATCH_NO_THREADING)
47328 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
47329     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47330 #elif defined (JITTER_REPLICATE)
47331 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
47332 #else
47333 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
47334 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47335 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47336 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47337 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47338 #   define JITTER_ARGF1 JITTER_ARGP1
47339 
47340 #else
47341   /* Define argument-access macros assuming that fast branches are disabled. */
47342     /* The 0th argument is a residual literal. */
47343 #if defined(JITTER_DISPATCH_NO_THREADING)
47344 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47345     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47346 #elif defined (JITTER_REPLICATE)
47347 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47348 #else
47349 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47350 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47351 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47352 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47353 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47354 #   define JITTER_ARGF0 JITTER_ARGP0
47355 
47356     /* The 1th argument is a residual label. */
47357 #if defined(JITTER_DISPATCH_NO_THREADING)
47358 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
47359     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47360 #elif defined (JITTER_REPLICATE)
47361 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
47362 #else
47363 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
47364 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47365 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47366 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47367 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47368 #   define JITTER_ARGF1 JITTER_ARGP1
47369 
47370 # endif // #ifdef JITTER_HAVE_PATCH_IN
47371 
47372 #ifdef JITTER_REPLICATE
47373     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47374        it on the stack rather than in read-only memory.  I had to do this to prevent
47375        a GCC 8 snapshot on SH from being too clever. */
47376     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47377     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47378        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47379        load the relocated part crashes.
47380                  mov.w     .L1667,r0
47381                  mov.l     @(r0,r15),r1
47382                  jmp       @r1
47383        r15 is the stack pointer.  The constant at .L1667 is
47384           .L1667:
47385                  .short    232
47386        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47387        can't work as an immediate.  Shall I keep these code pointers as a single array?
47388        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47389        but the problem will be the same. */
47390     /* Jump to non-relocatable code. */
47391     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47392 
47393     /* Here the residual arity is given as zero: it's too late to
47394        skip residuals, since we've already jumped and this code is
47395        unreachable.  The instruction pointer, if any, is advanced
47396        in the non-relocatable code. */
47397     JITTER_INSTRUCTION_EPILOG_(*pop-to-global-defined/nR/fR*-no-fast-branches, _Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches, 0)
47398 
47399     /* Relocated code will jump to this label in non-relocated code. */
47400   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47401     JITTER_COMMENT_IN_ASM_("*pop-to-global-defined/nR/fR*-no-fast-branches non-relocatable code");
47402 #endif // #ifdef JITTER_REPLICATE
47403 #if defined (JITTER_PROFILE_SAMPLE)
47404   JITTER_PROFILE_SAMPLE_UPDATE
47405      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47406       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47407   /* Force the compiler not move sample-profiling instrumentation
47408      beyond this point; this way the actual user code is timed.
47409      This is still not perfect, as residuals are materialised before
47410      we arrive here, but should be adequate at least for slow VM
47411      instructions. */
47412   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47413 #endif
47414 #if defined (JITTER_PROFILE_COUNT)
47415   /* Notice that, differently from the code above, this
47416      instrumentation code *can* be reordered freely: as long as a
47417      VM instruction is counted, the count increment can be placed
47418      anyehere.  Let GCC move this code and possibly achieve better
47419      throughput by exploiting instruction-level parallelism and
47420      therefore approximate more closely a non-profiled build. */
47421   JITTER_PROFILE_COUNT_UPDATE
47422      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47423       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47424 #endif
47425 
47426 /* User-specified code, instruction-beginning-c part: beginning. */
47427 
47428 
47429 /* User-specified code, instruction-beginning-c part: end */
47430 
47431 
47432     /* User code for *pop-to-global-defined/nR/fR*-no-fast-branches . */
47433 
47434     jitterlisp_object tagged_symbol = JITTER_ARGN0;
47435     struct jitterlisp_symbol *symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
47436 #ifndef JITTERLISP_UNSAFE
47437     JITTER_BRANCH_FAST_IF_NONZERO (symbol->global_constant, JITTER_ARGF1);
47438     JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
47439                                  JITTER_ARGF1);
47440 #endif // #ifndef JITTERLISP_UNSAFE
47441     symbol->global_value = JITTER_TOP_MAINSTACK();
47442     JITTER_DROP_MAINSTACK();
47443 
47444     /* End of the user code for *pop-to-global-defined/nR/fR*-no-fast-branches . */
47445 
47446 /* User-specified code, instruction-end-c part: beginning. */
47447 
47448 
47449 /* User-specified code, instruction-end-c part: end */
47450 
47451 #ifdef JITTER_REPLICATE
47452     /* Advance the instruction pointer, if any, to skip residuals;
47453        then jump back to replicated code. */
47454     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
47455     JITTER_SKIP_RESIDUALS_;
47456     goto * _jitter_back_to_replicated_code_pointer;
47457 #endif // #ifdef JITTER_REPLICATE
47458 
47459     /* Undefine the *pop-to-global-defined/nR/fR*-no-fast-branches argument macros so they can't be used
47460        by mistake in the instruction body coming next. */
47461 #   undef JITTER_SLOW_REGISTER_OFFSET0
47462 #   undef JITTER_ARG0
47463 #   undef JITTER_ARGN0
47464 #   undef JITTER_ARGU0
47465 #   undef JITTER_ARGP0
47466 #   undef JITTER_ARGF0
47467 #   undef JITTER_SLOW_REGISTER_OFFSET1
47468 #   undef JITTER_ARG1
47469 #   undef JITTER_ARGN1
47470 #   undef JITTER_ARGU1
47471 #   undef JITTER_ARGP1
47472 #   undef JITTER_ARGF1
47473 
47474 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47475 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47476 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47477 
47478   }
47479 #ifndef JITTER_REPLICATE
47480  JITTER_INSTRUCTION_EPILOG_(*pop-to-global-defined/nR/fR*-no-fast-branches, _Apop_mto_mglobal_mdefined__nR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47481 #endif // #ifndef JITTER_REPLICATE
47482 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47483 
47484   JITTER_INSTRUCTION_PROLOG_(*primitive/nR/n0/fR*-no-fast-branches, _Aprimitive__nR__n0__fR_A_mno_mfast_mbranches, cold)
47485   {
47486     /* This specialized instruction is a replacement. */
47487 #   undef JITTER_BRANCH_FAST
47488 #   define JITTER_BRANCH_FAST JITTER_BRANCH
47489 #   undef JITTER_BRANCH_FAST_IF_ZERO
47490 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
47491 #   undef JITTER_BRANCH_FAST_IF_NONZERO
47492 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
47493 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
47494 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
47495 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
47496 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
47497 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
47498 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
47499 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
47500 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
47501 #   undef JITTER_BRANCH_FAST_IF_EQUAL
47502 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
47503 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47504 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47505 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47506 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47507 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47508 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47509 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47510 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47511 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47512 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47513 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47514 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47515 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47516 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47517 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47518 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47519 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47520 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47521 #   undef JITTER_BRANCH_FAST_IF_AND
47522 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47523 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47524 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47525 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47526 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47527 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47528 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47529 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47530 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47531 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47532 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47533 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47534 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47535 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47536 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47537 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47538 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47539 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47540 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47541 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47542 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47543 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47544 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47545 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47546 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47547 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47548 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47549 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47550 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47551     /* This specialized instruction is non-relocatable.
47552        Its 2-th argument, a literal, is the return address where to jump
47553        at the end, back to relocated code. */
47554 
47555 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       248
47556 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive/nR/n0/fR*-no-fast-branches
47557 
47558 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive__nR__n0__fR_A_mno_mfast_mbranches
47559 
47560   /* The residual arity for this instruction does not depend on fast labels. */
47561   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
47562 
47563   /* Define argument-access macros for *primitive/nR/n0/fR*-no-fast-branches . */
47564 #ifdef JITTER_HAVE_PATCH_IN
47565   /* Define argument-access macros assuming that fast branches are enabled. */
47566     /* The 0th argument is a residual literal. */
47567 #if defined(JITTER_DISPATCH_NO_THREADING)
47568 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47569     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47570 #elif defined (JITTER_REPLICATE)
47571 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47572 #else
47573 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47574 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47575 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47576 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47577 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47578 
47579     /* The 1th argument is a nonresidual literal. */
47580 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
47581 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47582 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47583 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47584 
47585     /* The 2th argument is a residual label. */
47586 #if defined(JITTER_DISPATCH_NO_THREADING)
47587 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
47588     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47589 #elif defined (JITTER_REPLICATE)
47590 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
47591 #else
47592 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
47593 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47594 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
47595 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
47596 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
47597 #   define JITTER_ARGF2 JITTER_ARGP2
47598 
47599 #else
47600   /* Define argument-access macros assuming that fast branches are disabled. */
47601     /* The 0th argument is a residual literal. */
47602 #if defined(JITTER_DISPATCH_NO_THREADING)
47603 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47604     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47605 #elif defined (JITTER_REPLICATE)
47606 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47607 #else
47608 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47609 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47610 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47611 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47612 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47613 #   define JITTER_ARGF0 JITTER_ARGP0
47614 
47615     /* The 1th argument is a nonresidual literal. */
47616 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 0L})
47617 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47618 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47619 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47620 #   define JITTER_ARGF1 JITTER_ARGP1
47621 
47622     /* The 2th argument is a residual label. */
47623 #if defined(JITTER_DISPATCH_NO_THREADING)
47624 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
47625     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47626 #elif defined (JITTER_REPLICATE)
47627 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
47628 #else
47629 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
47630 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47631 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
47632 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
47633 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
47634 #   define JITTER_ARGF2 JITTER_ARGP2
47635 
47636 # endif // #ifdef JITTER_HAVE_PATCH_IN
47637 
47638 #ifdef JITTER_REPLICATE
47639     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47640        it on the stack rather than in read-only memory.  I had to do this to prevent
47641        a GCC 8 snapshot on SH from being too clever. */
47642     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47643     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47644        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47645        load the relocated part crashes.
47646                  mov.w     .L1667,r0
47647                  mov.l     @(r0,r15),r1
47648                  jmp       @r1
47649        r15 is the stack pointer.  The constant at .L1667 is
47650           .L1667:
47651                  .short    232
47652        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47653        can't work as an immediate.  Shall I keep these code pointers as a single array?
47654        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47655        but the problem will be the same. */
47656     /* Jump to non-relocatable code. */
47657     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47658 
47659     /* Here the residual arity is given as zero: it's too late to
47660        skip residuals, since we've already jumped and this code is
47661        unreachable.  The instruction pointer, if any, is advanced
47662        in the non-relocatable code. */
47663     JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n0/fR*-no-fast-branches, _Aprimitive__nR__n0__fR_A_mno_mfast_mbranches, 0)
47664 
47665     /* Relocated code will jump to this label in non-relocated code. */
47666   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47667     JITTER_COMMENT_IN_ASM_("*primitive/nR/n0/fR*-no-fast-branches non-relocatable code");
47668 #endif // #ifdef JITTER_REPLICATE
47669 #if defined (JITTER_PROFILE_SAMPLE)
47670   JITTER_PROFILE_SAMPLE_UPDATE
47671      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47672       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47673   /* Force the compiler not move sample-profiling instrumentation
47674      beyond this point; this way the actual user code is timed.
47675      This is still not perfect, as residuals are materialised before
47676      we arrive here, but should be adequate at least for slow VM
47677      instructions. */
47678   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47679 #endif
47680 #if defined (JITTER_PROFILE_COUNT)
47681   /* Notice that, differently from the code above, this
47682      instrumentation code *can* be reordered freely: as long as a
47683      VM instruction is counted, the count increment can be placed
47684      anyehere.  Let GCC move this code and possibly achieve better
47685      throughput by exploiting instruction-level parallelism and
47686      therefore approximate more closely a non-profiled build. */
47687   JITTER_PROFILE_COUNT_UPDATE
47688      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47689       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47690 #endif
47691 
47692 /* User-specified code, instruction-beginning-c part: beginning. */
47693 
47694 
47695 /* User-specified code, instruction-beginning-c part: end */
47696 
47697 
47698     /* User code for *primitive/nR/n0/fR*-no-fast-branches . */
47699 
47700     /* The error-handling label is not actually used in this case: the
47701        primitive function, written in C, has its own handling.  It's
47702        harmless to have it anyway, as it makes the C code generator
47703        more uniform. */
47704     jitterlisp_primitive_function p
47705       = (jitterlisp_primitive_function) JITTER_ARGP0;
47706     const jitter_uint in_arity = JITTER_ARGN1;
47707     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
47708     //asm volatile ("nop");
47709     jitterlisp_object *first_arg
47710       // FIXME: add a stack operator to compute this address.
47711       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
47712     /* This workaround is needed for Alpha.  I have macros to make this nicer in
47713        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
47714        Jitter. */
47715 /*
47716     void *saved_gp;
47717     asm volatile ("stq $gp, %[saved_gp]"
47718                   : [saved_gp] "=o" (saved_gp),
47719                     "+X" (p));
47720 */
47721     jitterlisp_object res = p (first_arg);
47722     /* Second part of the Alpha workaround. */
47723 /*
47724     asm volatile ("ldq $gp, %[saved_gp]"
47725                   : "+X" (res)
47726                   : [saved_gp] "o" (saved_gp));
47727 */
47728 
47729     jitter_uint i;
47730     // Remove as many elements as the primitive in-arity, but not more:
47731     // the top unspecified value we pushed will be replaced with the result.
47732     for (i = 0; i < in_arity; i ++)
47733       JITTER_NIP_MAINSTACK();
47734     //asm ("unop" : "+g" (jitter_state_runtime));
47735     JITTER_TOP_MAINSTACK() = res;
47736 
47737     /* End of the user code for *primitive/nR/n0/fR*-no-fast-branches . */
47738 
47739 /* User-specified code, instruction-end-c part: beginning. */
47740 
47741 
47742 /* User-specified code, instruction-end-c part: end */
47743 
47744 #ifdef JITTER_REPLICATE
47745     /* Advance the instruction pointer, if any, to skip residuals;
47746        then jump back to replicated code. */
47747     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP2;
47748     JITTER_SKIP_RESIDUALS_;
47749     goto * _jitter_back_to_replicated_code_pointer;
47750 #endif // #ifdef JITTER_REPLICATE
47751 
47752     /* Undefine the *primitive/nR/n0/fR*-no-fast-branches argument macros so they can't be used
47753        by mistake in the instruction body coming next. */
47754 #   undef JITTER_SLOW_REGISTER_OFFSET0
47755 #   undef JITTER_ARG0
47756 #   undef JITTER_ARGN0
47757 #   undef JITTER_ARGU0
47758 #   undef JITTER_ARGP0
47759 #   undef JITTER_ARGF0
47760 #   undef JITTER_SLOW_REGISTER_OFFSET1
47761 #   undef JITTER_ARG1
47762 #   undef JITTER_ARGN1
47763 #   undef JITTER_ARGU1
47764 #   undef JITTER_ARGP1
47765 #   undef JITTER_ARGF1
47766 #   undef JITTER_SLOW_REGISTER_OFFSET2
47767 #   undef JITTER_ARG2
47768 #   undef JITTER_ARGN2
47769 #   undef JITTER_ARGU2
47770 #   undef JITTER_ARGP2
47771 #   undef JITTER_ARGF2
47772 
47773 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
47774 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
47775 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
47776 
47777   }
47778 #ifndef JITTER_REPLICATE
47779  JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n0/fR*-no-fast-branches, _Aprimitive__nR__n0__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
47780 #endif // #ifndef JITTER_REPLICATE
47781 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
47782 
47783   JITTER_INSTRUCTION_PROLOG_(*primitive/nR/n1/fR*-no-fast-branches, _Aprimitive__nR__n1__fR_A_mno_mfast_mbranches, cold)
47784   {
47785     /* This specialized instruction is a replacement. */
47786 #   undef JITTER_BRANCH_FAST
47787 #   define JITTER_BRANCH_FAST JITTER_BRANCH
47788 #   undef JITTER_BRANCH_FAST_IF_ZERO
47789 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
47790 #   undef JITTER_BRANCH_FAST_IF_NONZERO
47791 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
47792 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
47793 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
47794 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
47795 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
47796 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
47797 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
47798 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
47799 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
47800 #   undef JITTER_BRANCH_FAST_IF_EQUAL
47801 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
47802 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
47803 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
47804 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
47805 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
47806 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
47807 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
47808 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
47809 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
47810 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
47811 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
47812 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
47813 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
47814 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
47815 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
47816 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
47817 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
47818 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
47819 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
47820 #   undef JITTER_BRANCH_FAST_IF_AND
47821 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
47822 #   undef JITTER_BRANCH_FAST_IF_NOTAND
47823 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
47824 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
47825 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
47826 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
47827 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
47828 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
47829 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
47830 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
47831 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
47832 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
47833 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
47834 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
47835 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
47836 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
47837 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
47838 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
47839 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
47840 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
47841 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
47842 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
47843 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
47844 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
47845 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
47846 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
47847 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
47848 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
47849 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
47850     /* This specialized instruction is non-relocatable.
47851        Its 2-th argument, a literal, is the return address where to jump
47852        at the end, back to relocated code. */
47853 
47854 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       249
47855 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive/nR/n1/fR*-no-fast-branches
47856 
47857 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive__nR__n1__fR_A_mno_mfast_mbranches
47858 
47859   /* The residual arity for this instruction does not depend on fast labels. */
47860   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
47861 
47862   /* Define argument-access macros for *primitive/nR/n1/fR*-no-fast-branches . */
47863 #ifdef JITTER_HAVE_PATCH_IN
47864   /* Define argument-access macros assuming that fast branches are enabled. */
47865     /* The 0th argument is a residual literal. */
47866 #if defined(JITTER_DISPATCH_NO_THREADING)
47867 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47868     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47869 #elif defined (JITTER_REPLICATE)
47870 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47871 #else
47872 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47873 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47874 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47875 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47876 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47877 
47878     /* The 1th argument is a nonresidual literal. */
47879 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
47880 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47881 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47882 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47883 
47884     /* The 2th argument is a residual label. */
47885 #if defined(JITTER_DISPATCH_NO_THREADING)
47886 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
47887     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47888 #elif defined (JITTER_REPLICATE)
47889 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
47890 #else
47891 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
47892 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47893 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
47894 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
47895 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
47896 #   define JITTER_ARGF2 JITTER_ARGP2
47897 
47898 #else
47899   /* Define argument-access macros assuming that fast branches are disabled. */
47900     /* The 0th argument is a residual literal. */
47901 #if defined(JITTER_DISPATCH_NO_THREADING)
47902 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
47903     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
47904 #elif defined (JITTER_REPLICATE)
47905 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
47906 #else
47907 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
47908 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47909 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
47910 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
47911 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
47912 #   define JITTER_ARGF0 JITTER_ARGP0
47913 
47914     /* The 1th argument is a nonresidual literal. */
47915 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 1L})
47916 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
47917 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
47918 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
47919 #   define JITTER_ARGF1 JITTER_ARGP1
47920 
47921     /* The 2th argument is a residual label. */
47922 #if defined(JITTER_DISPATCH_NO_THREADING)
47923 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
47924     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
47925 #elif defined (JITTER_REPLICATE)
47926 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
47927 #else
47928 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
47929 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
47930 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
47931 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
47932 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
47933 #   define JITTER_ARGF2 JITTER_ARGP2
47934 
47935 # endif // #ifdef JITTER_HAVE_PATCH_IN
47936 
47937 #ifdef JITTER_REPLICATE
47938     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
47939        it on the stack rather than in read-only memory.  I had to do this to prevent
47940        a GCC 8 snapshot on SH from being too clever. */
47941     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47942     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
47943        in memory, as a 16-bit constant; and since it reads it with a PC-relative
47944        load the relocated part crashes.
47945                  mov.w     .L1667,r0
47946                  mov.l     @(r0,r15),r1
47947                  jmp       @r1
47948        r15 is the stack pointer.  The constant at .L1667 is
47949           .L1667:
47950                  .short    232
47951        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
47952        can't work as an immediate.  Shall I keep these code pointers as a single array?
47953        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
47954        but the problem will be the same. */
47955     /* Jump to non-relocatable code. */
47956     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
47957 
47958     /* Here the residual arity is given as zero: it's too late to
47959        skip residuals, since we've already jumped and this code is
47960        unreachable.  The instruction pointer, if any, is advanced
47961        in the non-relocatable code. */
47962     JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n1/fR*-no-fast-branches, _Aprimitive__nR__n1__fR_A_mno_mfast_mbranches, 0)
47963 
47964     /* Relocated code will jump to this label in non-relocated code. */
47965   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
47966     JITTER_COMMENT_IN_ASM_("*primitive/nR/n1/fR*-no-fast-branches non-relocatable code");
47967 #endif // #ifdef JITTER_REPLICATE
47968 #if defined (JITTER_PROFILE_SAMPLE)
47969   JITTER_PROFILE_SAMPLE_UPDATE
47970      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47971       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47972   /* Force the compiler not move sample-profiling instrumentation
47973      beyond this point; this way the actual user code is timed.
47974      This is still not perfect, as residuals are materialised before
47975      we arrive here, but should be adequate at least for slow VM
47976      instructions. */
47977   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
47978 #endif
47979 #if defined (JITTER_PROFILE_COUNT)
47980   /* Notice that, differently from the code above, this
47981      instrumentation code *can* be reordered freely: as long as a
47982      VM instruction is counted, the count increment can be placed
47983      anyehere.  Let GCC move this code and possibly achieve better
47984      throughput by exploiting instruction-level parallelism and
47985      therefore approximate more closely a non-profiled build. */
47986   JITTER_PROFILE_COUNT_UPDATE
47987      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
47988       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
47989 #endif
47990 
47991 /* User-specified code, instruction-beginning-c part: beginning. */
47992 
47993 
47994 /* User-specified code, instruction-beginning-c part: end */
47995 
47996 
47997     /* User code for *primitive/nR/n1/fR*-no-fast-branches . */
47998 
47999     /* The error-handling label is not actually used in this case: the
48000        primitive function, written in C, has its own handling.  It's
48001        harmless to have it anyway, as it makes the C code generator
48002        more uniform. */
48003     jitterlisp_primitive_function p
48004       = (jitterlisp_primitive_function) JITTER_ARGP0;
48005     const jitter_uint in_arity = JITTER_ARGN1;
48006     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
48007     //asm volatile ("nop");
48008     jitterlisp_object *first_arg
48009       // FIXME: add a stack operator to compute this address.
48010       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
48011     /* This workaround is needed for Alpha.  I have macros to make this nicer in
48012        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
48013        Jitter. */
48014 /*
48015     void *saved_gp;
48016     asm volatile ("stq $gp, %[saved_gp]"
48017                   : [saved_gp] "=o" (saved_gp),
48018                     "+X" (p));
48019 */
48020     jitterlisp_object res = p (first_arg);
48021     /* Second part of the Alpha workaround. */
48022 /*
48023     asm volatile ("ldq $gp, %[saved_gp]"
48024                   : "+X" (res)
48025                   : [saved_gp] "o" (saved_gp));
48026 */
48027 
48028     jitter_uint i;
48029     // Remove as many elements as the primitive in-arity, but not more:
48030     // the top unspecified value we pushed will be replaced with the result.
48031     for (i = 0; i < in_arity; i ++)
48032       JITTER_NIP_MAINSTACK();
48033     //asm ("unop" : "+g" (jitter_state_runtime));
48034     JITTER_TOP_MAINSTACK() = res;
48035 
48036     /* End of the user code for *primitive/nR/n1/fR*-no-fast-branches . */
48037 
48038 /* User-specified code, instruction-end-c part: beginning. */
48039 
48040 
48041 /* User-specified code, instruction-end-c part: end */
48042 
48043 #ifdef JITTER_REPLICATE
48044     /* Advance the instruction pointer, if any, to skip residuals;
48045        then jump back to replicated code. */
48046     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP2;
48047     JITTER_SKIP_RESIDUALS_;
48048     goto * _jitter_back_to_replicated_code_pointer;
48049 #endif // #ifdef JITTER_REPLICATE
48050 
48051     /* Undefine the *primitive/nR/n1/fR*-no-fast-branches argument macros so they can't be used
48052        by mistake in the instruction body coming next. */
48053 #   undef JITTER_SLOW_REGISTER_OFFSET0
48054 #   undef JITTER_ARG0
48055 #   undef JITTER_ARGN0
48056 #   undef JITTER_ARGU0
48057 #   undef JITTER_ARGP0
48058 #   undef JITTER_ARGF0
48059 #   undef JITTER_SLOW_REGISTER_OFFSET1
48060 #   undef JITTER_ARG1
48061 #   undef JITTER_ARGN1
48062 #   undef JITTER_ARGU1
48063 #   undef JITTER_ARGP1
48064 #   undef JITTER_ARGF1
48065 #   undef JITTER_SLOW_REGISTER_OFFSET2
48066 #   undef JITTER_ARG2
48067 #   undef JITTER_ARGN2
48068 #   undef JITTER_ARGU2
48069 #   undef JITTER_ARGP2
48070 #   undef JITTER_ARGF2
48071 
48072 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
48073 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
48074 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
48075 
48076   }
48077 #ifndef JITTER_REPLICATE
48078  JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n1/fR*-no-fast-branches, _Aprimitive__nR__n1__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
48079 #endif // #ifndef JITTER_REPLICATE
48080 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
48081 
48082   JITTER_INSTRUCTION_PROLOG_(*primitive/nR/n2/fR*-no-fast-branches, _Aprimitive__nR__n2__fR_A_mno_mfast_mbranches, cold)
48083   {
48084     /* This specialized instruction is a replacement. */
48085 #   undef JITTER_BRANCH_FAST
48086 #   define JITTER_BRANCH_FAST JITTER_BRANCH
48087 #   undef JITTER_BRANCH_FAST_IF_ZERO
48088 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
48089 #   undef JITTER_BRANCH_FAST_IF_NONZERO
48090 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
48091 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
48092 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
48093 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
48094 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
48095 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
48096 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
48097 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
48098 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
48099 #   undef JITTER_BRANCH_FAST_IF_EQUAL
48100 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
48101 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
48102 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
48103 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
48104 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
48105 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
48106 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
48107 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
48108 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
48109 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
48110 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
48111 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
48112 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
48113 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
48114 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
48115 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
48116 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
48117 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
48118 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
48119 #   undef JITTER_BRANCH_FAST_IF_AND
48120 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
48121 #   undef JITTER_BRANCH_FAST_IF_NOTAND
48122 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
48123 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
48124 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
48125 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
48126 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
48127 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
48128 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
48129 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
48130 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
48131 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
48132 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
48133 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
48134 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
48135 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
48136 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
48137 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
48138 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
48139 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
48140 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
48141 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
48142 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
48143 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
48144 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
48145 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
48146 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
48147 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
48148 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
48149     /* This specialized instruction is non-relocatable.
48150        Its 2-th argument, a literal, is the return address where to jump
48151        at the end, back to relocated code. */
48152 
48153 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       250
48154 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive/nR/n2/fR*-no-fast-branches
48155 
48156 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive__nR__n2__fR_A_mno_mfast_mbranches
48157 
48158   /* The residual arity for this instruction does not depend on fast labels. */
48159   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
48160 
48161   /* Define argument-access macros for *primitive/nR/n2/fR*-no-fast-branches . */
48162 #ifdef JITTER_HAVE_PATCH_IN
48163   /* Define argument-access macros assuming that fast branches are enabled. */
48164     /* The 0th argument is a residual literal. */
48165 #if defined(JITTER_DISPATCH_NO_THREADING)
48166 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
48167     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
48168 #elif defined (JITTER_REPLICATE)
48169 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
48170 #else
48171 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
48172 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48173 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
48174 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
48175 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
48176 
48177     /* The 1th argument is a nonresidual literal. */
48178 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
48179 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
48180 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
48181 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
48182 
48183     /* The 2th argument is a residual label. */
48184 #if defined(JITTER_DISPATCH_NO_THREADING)
48185 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
48186     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
48187 #elif defined (JITTER_REPLICATE)
48188 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
48189 #else
48190 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
48191 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48192 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
48193 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
48194 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
48195 #   define JITTER_ARGF2 JITTER_ARGP2
48196 
48197 #else
48198   /* Define argument-access macros assuming that fast branches are disabled. */
48199     /* The 0th argument is a residual literal. */
48200 #if defined(JITTER_DISPATCH_NO_THREADING)
48201 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
48202     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
48203 #elif defined (JITTER_REPLICATE)
48204 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
48205 #else
48206 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
48207 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48208 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
48209 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
48210 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
48211 #   define JITTER_ARGF0 JITTER_ARGP0
48212 
48213     /* The 1th argument is a nonresidual literal. */
48214 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 2L})
48215 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
48216 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
48217 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
48218 #   define JITTER_ARGF1 JITTER_ARGP1
48219 
48220     /* The 2th argument is a residual label. */
48221 #if defined(JITTER_DISPATCH_NO_THREADING)
48222 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
48223     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
48224 #elif defined (JITTER_REPLICATE)
48225 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
48226 #else
48227 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
48228 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48229 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
48230 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
48231 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
48232 #   define JITTER_ARGF2 JITTER_ARGP2
48233 
48234 # endif // #ifdef JITTER_HAVE_PATCH_IN
48235 
48236 #ifdef JITTER_REPLICATE
48237     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
48238        it on the stack rather than in read-only memory.  I had to do this to prevent
48239        a GCC 8 snapshot on SH from being too clever. */
48240     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
48241     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
48242        in memory, as a 16-bit constant; and since it reads it with a PC-relative
48243        load the relocated part crashes.
48244                  mov.w     .L1667,r0
48245                  mov.l     @(r0,r15),r1
48246                  jmp       @r1
48247        r15 is the stack pointer.  The constant at .L1667 is
48248           .L1667:
48249                  .short    232
48250        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
48251        can't work as an immediate.  Shall I keep these code pointers as a single array?
48252        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
48253        but the problem will be the same. */
48254     /* Jump to non-relocatable code. */
48255     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
48256 
48257     /* Here the residual arity is given as zero: it's too late to
48258        skip residuals, since we've already jumped and this code is
48259        unreachable.  The instruction pointer, if any, is advanced
48260        in the non-relocatable code. */
48261     JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n2/fR*-no-fast-branches, _Aprimitive__nR__n2__fR_A_mno_mfast_mbranches, 0)
48262 
48263     /* Relocated code will jump to this label in non-relocated code. */
48264   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
48265     JITTER_COMMENT_IN_ASM_("*primitive/nR/n2/fR*-no-fast-branches non-relocatable code");
48266 #endif // #ifdef JITTER_REPLICATE
48267 #if defined (JITTER_PROFILE_SAMPLE)
48268   JITTER_PROFILE_SAMPLE_UPDATE
48269      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
48270       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
48271   /* Force the compiler not move sample-profiling instrumentation
48272      beyond this point; this way the actual user code is timed.
48273      This is still not perfect, as residuals are materialised before
48274      we arrive here, but should be adequate at least for slow VM
48275      instructions. */
48276   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
48277 #endif
48278 #if defined (JITTER_PROFILE_COUNT)
48279   /* Notice that, differently from the code above, this
48280      instrumentation code *can* be reordered freely: as long as a
48281      VM instruction is counted, the count increment can be placed
48282      anyehere.  Let GCC move this code and possibly achieve better
48283      throughput by exploiting instruction-level parallelism and
48284      therefore approximate more closely a non-profiled build. */
48285   JITTER_PROFILE_COUNT_UPDATE
48286      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
48287       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
48288 #endif
48289 
48290 /* User-specified code, instruction-beginning-c part: beginning. */
48291 
48292 
48293 /* User-specified code, instruction-beginning-c part: end */
48294 
48295 
48296     /* User code for *primitive/nR/n2/fR*-no-fast-branches . */
48297 
48298     /* The error-handling label is not actually used in this case: the
48299        primitive function, written in C, has its own handling.  It's
48300        harmless to have it anyway, as it makes the C code generator
48301        more uniform. */
48302     jitterlisp_primitive_function p
48303       = (jitterlisp_primitive_function) JITTER_ARGP0;
48304     const jitter_uint in_arity = JITTER_ARGN1;
48305     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
48306     //asm volatile ("nop");
48307     jitterlisp_object *first_arg
48308       // FIXME: add a stack operator to compute this address.
48309       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
48310     /* This workaround is needed for Alpha.  I have macros to make this nicer in
48311        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
48312        Jitter. */
48313 /*
48314     void *saved_gp;
48315     asm volatile ("stq $gp, %[saved_gp]"
48316                   : [saved_gp] "=o" (saved_gp),
48317                     "+X" (p));
48318 */
48319     jitterlisp_object res = p (first_arg);
48320     /* Second part of the Alpha workaround. */
48321 /*
48322     asm volatile ("ldq $gp, %[saved_gp]"
48323                   : "+X" (res)
48324                   : [saved_gp] "o" (saved_gp));
48325 */
48326 
48327     jitter_uint i;
48328     // Remove as many elements as the primitive in-arity, but not more:
48329     // the top unspecified value we pushed will be replaced with the result.
48330     for (i = 0; i < in_arity; i ++)
48331       JITTER_NIP_MAINSTACK();
48332     //asm ("unop" : "+g" (jitter_state_runtime));
48333     JITTER_TOP_MAINSTACK() = res;
48334 
48335     /* End of the user code for *primitive/nR/n2/fR*-no-fast-branches . */
48336 
48337 /* User-specified code, instruction-end-c part: beginning. */
48338 
48339 
48340 /* User-specified code, instruction-end-c part: end */
48341 
48342 #ifdef JITTER_REPLICATE
48343     /* Advance the instruction pointer, if any, to skip residuals;
48344        then jump back to replicated code. */
48345     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP2;
48346     JITTER_SKIP_RESIDUALS_;
48347     goto * _jitter_back_to_replicated_code_pointer;
48348 #endif // #ifdef JITTER_REPLICATE
48349 
48350     /* Undefine the *primitive/nR/n2/fR*-no-fast-branches argument macros so they can't be used
48351        by mistake in the instruction body coming next. */
48352 #   undef JITTER_SLOW_REGISTER_OFFSET0
48353 #   undef JITTER_ARG0
48354 #   undef JITTER_ARGN0
48355 #   undef JITTER_ARGU0
48356 #   undef JITTER_ARGP0
48357 #   undef JITTER_ARGF0
48358 #   undef JITTER_SLOW_REGISTER_OFFSET1
48359 #   undef JITTER_ARG1
48360 #   undef JITTER_ARGN1
48361 #   undef JITTER_ARGU1
48362 #   undef JITTER_ARGP1
48363 #   undef JITTER_ARGF1
48364 #   undef JITTER_SLOW_REGISTER_OFFSET2
48365 #   undef JITTER_ARG2
48366 #   undef JITTER_ARGN2
48367 #   undef JITTER_ARGU2
48368 #   undef JITTER_ARGP2
48369 #   undef JITTER_ARGF2
48370 
48371 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
48372 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
48373 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
48374 
48375   }
48376 #ifndef JITTER_REPLICATE
48377  JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n2/fR*-no-fast-branches, _Aprimitive__nR__n2__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
48378 #endif // #ifndef JITTER_REPLICATE
48379 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
48380 
48381   JITTER_INSTRUCTION_PROLOG_(*primitive/nR/n3/fR*-no-fast-branches, _Aprimitive__nR__n3__fR_A_mno_mfast_mbranches, cold)
48382   {
48383     /* This specialized instruction is a replacement. */
48384 #   undef JITTER_BRANCH_FAST
48385 #   define JITTER_BRANCH_FAST JITTER_BRANCH
48386 #   undef JITTER_BRANCH_FAST_IF_ZERO
48387 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
48388 #   undef JITTER_BRANCH_FAST_IF_NONZERO
48389 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
48390 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
48391 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
48392 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
48393 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
48394 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
48395 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
48396 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
48397 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
48398 #   undef JITTER_BRANCH_FAST_IF_EQUAL
48399 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
48400 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
48401 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
48402 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
48403 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
48404 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
48405 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
48406 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
48407 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
48408 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
48409 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
48410 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
48411 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
48412 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
48413 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
48414 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
48415 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
48416 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
48417 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
48418 #   undef JITTER_BRANCH_FAST_IF_AND
48419 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
48420 #   undef JITTER_BRANCH_FAST_IF_NOTAND
48421 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
48422 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
48423 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
48424 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
48425 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
48426 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
48427 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
48428 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
48429 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
48430 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
48431 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
48432 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
48433 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
48434 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
48435 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
48436 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
48437 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
48438 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
48439 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
48440 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
48441 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
48442 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
48443 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
48444 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
48445 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
48446 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
48447 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
48448     /* This specialized instruction is non-relocatable.
48449        Its 2-th argument, a literal, is the return address where to jump
48450        at the end, back to relocated code. */
48451 
48452 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       251
48453 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive/nR/n3/fR*-no-fast-branches
48454 
48455 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive__nR__n3__fR_A_mno_mfast_mbranches
48456 
48457   /* The residual arity for this instruction does not depend on fast labels. */
48458   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
48459 
48460   /* Define argument-access macros for *primitive/nR/n3/fR*-no-fast-branches . */
48461 #ifdef JITTER_HAVE_PATCH_IN
48462   /* Define argument-access macros assuming that fast branches are enabled. */
48463     /* The 0th argument is a residual literal. */
48464 #if defined(JITTER_DISPATCH_NO_THREADING)
48465 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
48466     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
48467 #elif defined (JITTER_REPLICATE)
48468 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
48469 #else
48470 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
48471 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48472 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
48473 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
48474 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
48475 
48476     /* The 1th argument is a nonresidual literal. */
48477 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
48478 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
48479 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
48480 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
48481 
48482     /* The 2th argument is a residual label. */
48483 #if defined(JITTER_DISPATCH_NO_THREADING)
48484 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
48485     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
48486 #elif defined (JITTER_REPLICATE)
48487 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
48488 #else
48489 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
48490 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48491 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
48492 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
48493 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
48494 #   define JITTER_ARGF2 JITTER_ARGP2
48495 
48496 #else
48497   /* Define argument-access macros assuming that fast branches are disabled. */
48498     /* The 0th argument is a residual literal. */
48499 #if defined(JITTER_DISPATCH_NO_THREADING)
48500 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
48501     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
48502 #elif defined (JITTER_REPLICATE)
48503 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
48504 #else
48505 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
48506 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48507 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
48508 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
48509 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
48510 #   define JITTER_ARGF0 JITTER_ARGP0
48511 
48512     /* The 1th argument is a nonresidual literal. */
48513 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 3L})
48514 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
48515 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
48516 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
48517 #   define JITTER_ARGF1 JITTER_ARGP1
48518 
48519     /* The 2th argument is a residual label. */
48520 #if defined(JITTER_DISPATCH_NO_THREADING)
48521 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
48522     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
48523 #elif defined (JITTER_REPLICATE)
48524 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
48525 #else
48526 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
48527 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48528 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
48529 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
48530 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
48531 #   define JITTER_ARGF2 JITTER_ARGP2
48532 
48533 # endif // #ifdef JITTER_HAVE_PATCH_IN
48534 
48535 #ifdef JITTER_REPLICATE
48536     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
48537        it on the stack rather than in read-only memory.  I had to do this to prevent
48538        a GCC 8 snapshot on SH from being too clever. */
48539     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
48540     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
48541        in memory, as a 16-bit constant; and since it reads it with a PC-relative
48542        load the relocated part crashes.
48543                  mov.w     .L1667,r0
48544                  mov.l     @(r0,r15),r1
48545                  jmp       @r1
48546        r15 is the stack pointer.  The constant at .L1667 is
48547           .L1667:
48548                  .short    232
48549        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
48550        can't work as an immediate.  Shall I keep these code pointers as a single array?
48551        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
48552        but the problem will be the same. */
48553     /* Jump to non-relocatable code. */
48554     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
48555 
48556     /* Here the residual arity is given as zero: it's too late to
48557        skip residuals, since we've already jumped and this code is
48558        unreachable.  The instruction pointer, if any, is advanced
48559        in the non-relocatable code. */
48560     JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n3/fR*-no-fast-branches, _Aprimitive__nR__n3__fR_A_mno_mfast_mbranches, 0)
48561 
48562     /* Relocated code will jump to this label in non-relocated code. */
48563   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
48564     JITTER_COMMENT_IN_ASM_("*primitive/nR/n3/fR*-no-fast-branches non-relocatable code");
48565 #endif // #ifdef JITTER_REPLICATE
48566 #if defined (JITTER_PROFILE_SAMPLE)
48567   JITTER_PROFILE_SAMPLE_UPDATE
48568      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
48569       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
48570   /* Force the compiler not move sample-profiling instrumentation
48571      beyond this point; this way the actual user code is timed.
48572      This is still not perfect, as residuals are materialised before
48573      we arrive here, but should be adequate at least for slow VM
48574      instructions. */
48575   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
48576 #endif
48577 #if defined (JITTER_PROFILE_COUNT)
48578   /* Notice that, differently from the code above, this
48579      instrumentation code *can* be reordered freely: as long as a
48580      VM instruction is counted, the count increment can be placed
48581      anyehere.  Let GCC move this code and possibly achieve better
48582      throughput by exploiting instruction-level parallelism and
48583      therefore approximate more closely a non-profiled build. */
48584   JITTER_PROFILE_COUNT_UPDATE
48585      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
48586       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
48587 #endif
48588 
48589 /* User-specified code, instruction-beginning-c part: beginning. */
48590 
48591 
48592 /* User-specified code, instruction-beginning-c part: end */
48593 
48594 
48595     /* User code for *primitive/nR/n3/fR*-no-fast-branches . */
48596 
48597     /* The error-handling label is not actually used in this case: the
48598        primitive function, written in C, has its own handling.  It's
48599        harmless to have it anyway, as it makes the C code generator
48600        more uniform. */
48601     jitterlisp_primitive_function p
48602       = (jitterlisp_primitive_function) JITTER_ARGP0;
48603     const jitter_uint in_arity = JITTER_ARGN1;
48604     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
48605     //asm volatile ("nop");
48606     jitterlisp_object *first_arg
48607       // FIXME: add a stack operator to compute this address.
48608       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
48609     /* This workaround is needed for Alpha.  I have macros to make this nicer in
48610        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
48611        Jitter. */
48612 /*
48613     void *saved_gp;
48614     asm volatile ("stq $gp, %[saved_gp]"
48615                   : [saved_gp] "=o" (saved_gp),
48616                     "+X" (p));
48617 */
48618     jitterlisp_object res = p (first_arg);
48619     /* Second part of the Alpha workaround. */
48620 /*
48621     asm volatile ("ldq $gp, %[saved_gp]"
48622                   : "+X" (res)
48623                   : [saved_gp] "o" (saved_gp));
48624 */
48625 
48626     jitter_uint i;
48627     // Remove as many elements as the primitive in-arity, but not more:
48628     // the top unspecified value we pushed will be replaced with the result.
48629     for (i = 0; i < in_arity; i ++)
48630       JITTER_NIP_MAINSTACK();
48631     //asm ("unop" : "+g" (jitter_state_runtime));
48632     JITTER_TOP_MAINSTACK() = res;
48633 
48634     /* End of the user code for *primitive/nR/n3/fR*-no-fast-branches . */
48635 
48636 /* User-specified code, instruction-end-c part: beginning. */
48637 
48638 
48639 /* User-specified code, instruction-end-c part: end */
48640 
48641 #ifdef JITTER_REPLICATE
48642     /* Advance the instruction pointer, if any, to skip residuals;
48643        then jump back to replicated code. */
48644     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP2;
48645     JITTER_SKIP_RESIDUALS_;
48646     goto * _jitter_back_to_replicated_code_pointer;
48647 #endif // #ifdef JITTER_REPLICATE
48648 
48649     /* Undefine the *primitive/nR/n3/fR*-no-fast-branches argument macros so they can't be used
48650        by mistake in the instruction body coming next. */
48651 #   undef JITTER_SLOW_REGISTER_OFFSET0
48652 #   undef JITTER_ARG0
48653 #   undef JITTER_ARGN0
48654 #   undef JITTER_ARGU0
48655 #   undef JITTER_ARGP0
48656 #   undef JITTER_ARGF0
48657 #   undef JITTER_SLOW_REGISTER_OFFSET1
48658 #   undef JITTER_ARG1
48659 #   undef JITTER_ARGN1
48660 #   undef JITTER_ARGU1
48661 #   undef JITTER_ARGP1
48662 #   undef JITTER_ARGF1
48663 #   undef JITTER_SLOW_REGISTER_OFFSET2
48664 #   undef JITTER_ARG2
48665 #   undef JITTER_ARGN2
48666 #   undef JITTER_ARGU2
48667 #   undef JITTER_ARGP2
48668 #   undef JITTER_ARGF2
48669 
48670 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
48671 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
48672 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
48673 
48674   }
48675 #ifndef JITTER_REPLICATE
48676  JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n3/fR*-no-fast-branches, _Aprimitive__nR__n3__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
48677 #endif // #ifndef JITTER_REPLICATE
48678 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
48679 
48680   JITTER_INSTRUCTION_PROLOG_(*primitive/nR/n4/fR*-no-fast-branches, _Aprimitive__nR__n4__fR_A_mno_mfast_mbranches, cold)
48681   {
48682     /* This specialized instruction is a replacement. */
48683 #   undef JITTER_BRANCH_FAST
48684 #   define JITTER_BRANCH_FAST JITTER_BRANCH
48685 #   undef JITTER_BRANCH_FAST_IF_ZERO
48686 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
48687 #   undef JITTER_BRANCH_FAST_IF_NONZERO
48688 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
48689 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
48690 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
48691 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
48692 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
48693 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
48694 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
48695 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
48696 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
48697 #   undef JITTER_BRANCH_FAST_IF_EQUAL
48698 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
48699 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
48700 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
48701 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
48702 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
48703 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
48704 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
48705 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
48706 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
48707 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
48708 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
48709 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
48710 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
48711 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
48712 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
48713 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
48714 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
48715 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
48716 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
48717 #   undef JITTER_BRANCH_FAST_IF_AND
48718 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
48719 #   undef JITTER_BRANCH_FAST_IF_NOTAND
48720 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
48721 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
48722 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
48723 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
48724 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
48725 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
48726 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
48727 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
48728 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
48729 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
48730 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
48731 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
48732 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
48733 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
48734 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
48735 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
48736 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
48737 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
48738 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
48739 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
48740 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
48741 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
48742 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
48743 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
48744 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
48745 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
48746 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
48747     /* This specialized instruction is non-relocatable.
48748        Its 2-th argument, a literal, is the return address where to jump
48749        at the end, back to relocated code. */
48750 
48751 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       252
48752 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive/nR/n4/fR*-no-fast-branches
48753 
48754 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive__nR__n4__fR_A_mno_mfast_mbranches
48755 
48756   /* The residual arity for this instruction does not depend on fast labels. */
48757   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
48758 
48759   /* Define argument-access macros for *primitive/nR/n4/fR*-no-fast-branches . */
48760 #ifdef JITTER_HAVE_PATCH_IN
48761   /* Define argument-access macros assuming that fast branches are enabled. */
48762     /* The 0th argument is a residual literal. */
48763 #if defined(JITTER_DISPATCH_NO_THREADING)
48764 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
48765     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
48766 #elif defined (JITTER_REPLICATE)
48767 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
48768 #else
48769 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
48770 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48771 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
48772 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
48773 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
48774 
48775     /* The 1th argument is a nonresidual literal. */
48776 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
48777 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
48778 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
48779 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
48780 
48781     /* The 2th argument is a residual label. */
48782 #if defined(JITTER_DISPATCH_NO_THREADING)
48783 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
48784     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
48785 #elif defined (JITTER_REPLICATE)
48786 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
48787 #else
48788 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
48789 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48790 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
48791 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
48792 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
48793 #   define JITTER_ARGF2 JITTER_ARGP2
48794 
48795 #else
48796   /* Define argument-access macros assuming that fast branches are disabled. */
48797     /* The 0th argument is a residual literal. */
48798 #if defined(JITTER_DISPATCH_NO_THREADING)
48799 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
48800     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
48801 #elif defined (JITTER_REPLICATE)
48802 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
48803 #else
48804 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
48805 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48806 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
48807 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
48808 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
48809 #   define JITTER_ARGF0 JITTER_ARGP0
48810 
48811     /* The 1th argument is a nonresidual literal. */
48812 #   define JITTER_ARG1  ((const union jitter_word){.fixnum = 4L})
48813 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
48814 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
48815 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
48816 #   define JITTER_ARGF1 JITTER_ARGP1
48817 
48818     /* The 2th argument is a residual label. */
48819 #if defined(JITTER_DISPATCH_NO_THREADING)
48820 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_1
48821     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
48822 #elif defined (JITTER_REPLICATE)
48823 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[1])
48824 #else
48825 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
48826 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
48827 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
48828 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
48829 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
48830 #   define JITTER_ARGF2 JITTER_ARGP2
48831 
48832 # endif // #ifdef JITTER_HAVE_PATCH_IN
48833 
48834 #ifdef JITTER_REPLICATE
48835     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
48836        it on the stack rather than in read-only memory.  I had to do this to prevent
48837        a GCC 8 snapshot on SH from being too clever. */
48838     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
48839     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
48840        in memory, as a 16-bit constant; and since it reads it with a PC-relative
48841        load the relocated part crashes.
48842                  mov.w     .L1667,r0
48843                  mov.l     @(r0,r15),r1
48844                  jmp       @r1
48845        r15 is the stack pointer.  The constant at .L1667 is
48846           .L1667:
48847                  .short    232
48848        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
48849        can't work as an immediate.  Shall I keep these code pointers as a single array?
48850        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
48851        but the problem will be the same. */
48852     /* Jump to non-relocatable code. */
48853     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
48854 
48855     /* Here the residual arity is given as zero: it's too late to
48856        skip residuals, since we've already jumped and this code is
48857        unreachable.  The instruction pointer, if any, is advanced
48858        in the non-relocatable code. */
48859     JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n4/fR*-no-fast-branches, _Aprimitive__nR__n4__fR_A_mno_mfast_mbranches, 0)
48860 
48861     /* Relocated code will jump to this label in non-relocated code. */
48862   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
48863     JITTER_COMMENT_IN_ASM_("*primitive/nR/n4/fR*-no-fast-branches non-relocatable code");
48864 #endif // #ifdef JITTER_REPLICATE
48865 #if defined (JITTER_PROFILE_SAMPLE)
48866   JITTER_PROFILE_SAMPLE_UPDATE
48867      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
48868       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
48869   /* Force the compiler not move sample-profiling instrumentation
48870      beyond this point; this way the actual user code is timed.
48871      This is still not perfect, as residuals are materialised before
48872      we arrive here, but should be adequate at least for slow VM
48873      instructions. */
48874   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
48875 #endif
48876 #if defined (JITTER_PROFILE_COUNT)
48877   /* Notice that, differently from the code above, this
48878      instrumentation code *can* be reordered freely: as long as a
48879      VM instruction is counted, the count increment can be placed
48880      anyehere.  Let GCC move this code and possibly achieve better
48881      throughput by exploiting instruction-level parallelism and
48882      therefore approximate more closely a non-profiled build. */
48883   JITTER_PROFILE_COUNT_UPDATE
48884      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
48885       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
48886 #endif
48887 
48888 /* User-specified code, instruction-beginning-c part: beginning. */
48889 
48890 
48891 /* User-specified code, instruction-beginning-c part: end */
48892 
48893 
48894     /* User code for *primitive/nR/n4/fR*-no-fast-branches . */
48895 
48896     /* The error-handling label is not actually used in this case: the
48897        primitive function, written in C, has its own handling.  It's
48898        harmless to have it anyway, as it makes the C code generator
48899        more uniform. */
48900     jitterlisp_primitive_function p
48901       = (jitterlisp_primitive_function) JITTER_ARGP0;
48902     const jitter_uint in_arity = JITTER_ARGN1;
48903     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
48904     //asm volatile ("nop");
48905     jitterlisp_object *first_arg
48906       // FIXME: add a stack operator to compute this address.
48907       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
48908     /* This workaround is needed for Alpha.  I have macros to make this nicer in
48909        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
48910        Jitter. */
48911 /*
48912     void *saved_gp;
48913     asm volatile ("stq $gp, %[saved_gp]"
48914                   : [saved_gp] "=o" (saved_gp),
48915                     "+X" (p));
48916 */
48917     jitterlisp_object res = p (first_arg);
48918     /* Second part of the Alpha workaround. */
48919 /*
48920     asm volatile ("ldq $gp, %[saved_gp]"
48921                   : "+X" (res)
48922                   : [saved_gp] "o" (saved_gp));
48923 */
48924 
48925     jitter_uint i;
48926     // Remove as many elements as the primitive in-arity, but not more:
48927     // the top unspecified value we pushed will be replaced with the result.
48928     for (i = 0; i < in_arity; i ++)
48929       JITTER_NIP_MAINSTACK();
48930     //asm ("unop" : "+g" (jitter_state_runtime));
48931     JITTER_TOP_MAINSTACK() = res;
48932 
48933     /* End of the user code for *primitive/nR/n4/fR*-no-fast-branches . */
48934 
48935 /* User-specified code, instruction-end-c part: beginning. */
48936 
48937 
48938 /* User-specified code, instruction-end-c part: end */
48939 
48940 #ifdef JITTER_REPLICATE
48941     /* Advance the instruction pointer, if any, to skip residuals;
48942        then jump back to replicated code. */
48943     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP2;
48944     JITTER_SKIP_RESIDUALS_;
48945     goto * _jitter_back_to_replicated_code_pointer;
48946 #endif // #ifdef JITTER_REPLICATE
48947 
48948     /* Undefine the *primitive/nR/n4/fR*-no-fast-branches argument macros so they can't be used
48949        by mistake in the instruction body coming next. */
48950 #   undef JITTER_SLOW_REGISTER_OFFSET0
48951 #   undef JITTER_ARG0
48952 #   undef JITTER_ARGN0
48953 #   undef JITTER_ARGU0
48954 #   undef JITTER_ARGP0
48955 #   undef JITTER_ARGF0
48956 #   undef JITTER_SLOW_REGISTER_OFFSET1
48957 #   undef JITTER_ARG1
48958 #   undef JITTER_ARGN1
48959 #   undef JITTER_ARGU1
48960 #   undef JITTER_ARGP1
48961 #   undef JITTER_ARGF1
48962 #   undef JITTER_SLOW_REGISTER_OFFSET2
48963 #   undef JITTER_ARG2
48964 #   undef JITTER_ARGN2
48965 #   undef JITTER_ARGU2
48966 #   undef JITTER_ARGP2
48967 #   undef JITTER_ARGF2
48968 
48969 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
48970 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
48971 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
48972 
48973   }
48974 #ifndef JITTER_REPLICATE
48975  JITTER_INSTRUCTION_EPILOG_(*primitive/nR/n4/fR*-no-fast-branches, _Aprimitive__nR__n4__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
48976 #endif // #ifndef JITTER_REPLICATE
48977 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
48978 
48979   JITTER_INSTRUCTION_PROLOG_(*primitive/nR/nR/fR*-no-fast-branches, _Aprimitive__nR__nR__fR_A_mno_mfast_mbranches, cold)
48980   {
48981     /* This specialized instruction is a replacement. */
48982 #   undef JITTER_BRANCH_FAST
48983 #   define JITTER_BRANCH_FAST JITTER_BRANCH
48984 #   undef JITTER_BRANCH_FAST_IF_ZERO
48985 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
48986 #   undef JITTER_BRANCH_FAST_IF_NONZERO
48987 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
48988 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
48989 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
48990 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
48991 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
48992 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
48993 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
48994 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
48995 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
48996 #   undef JITTER_BRANCH_FAST_IF_EQUAL
48997 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
48998 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
48999 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
49000 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
49001 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
49002 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
49003 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
49004 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
49005 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
49006 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
49007 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
49008 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
49009 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
49010 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
49011 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
49012 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
49013 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
49014 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
49015 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
49016 #   undef JITTER_BRANCH_FAST_IF_AND
49017 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
49018 #   undef JITTER_BRANCH_FAST_IF_NOTAND
49019 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
49020 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
49021 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
49022 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
49023 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
49024 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
49025 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
49026 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
49027 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
49028 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
49029 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
49030 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
49031 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
49032 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
49033 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
49034 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
49035 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
49036 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
49037 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
49038 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
49039 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
49040 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
49041 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
49042 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
49043 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
49044 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
49045 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
49046     /* This specialized instruction is non-relocatable.
49047        Its 2-th argument, a literal, is the return address where to jump
49048        at the end, back to relocated code. */
49049 
49050 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       253
49051 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive/nR/nR/fR*-no-fast-branches
49052 
49053 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive__nR__nR__fR_A_mno_mfast_mbranches
49054 
49055   /* The residual arity for this instruction does not depend on fast labels. */
49056   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 3
49057 
49058   /* Define argument-access macros for *primitive/nR/nR/fR*-no-fast-branches . */
49059 #ifdef JITTER_HAVE_PATCH_IN
49060   /* Define argument-access macros assuming that fast branches are enabled. */
49061     /* The 0th argument is a residual literal. */
49062 #if defined(JITTER_DISPATCH_NO_THREADING)
49063 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49064     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49065 #elif defined (JITTER_REPLICATE)
49066 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49067 #else
49068 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49069 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49070 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49071 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49072 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49073 
49074     /* The 1th argument is a residual literal. */
49075 #if defined(JITTER_DISPATCH_NO_THREADING)
49076 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
49077     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
49078 #elif defined (JITTER_REPLICATE)
49079 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
49080 #else
49081 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
49082 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49083 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
49084 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
49085 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
49086 
49087     /* The 2th argument is a residual label. */
49088 #if defined(JITTER_DISPATCH_NO_THREADING)
49089 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
49090     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
49091 #elif defined (JITTER_REPLICATE)
49092 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
49093 #else
49094 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
49095 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49096 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
49097 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
49098 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
49099 #   define JITTER_ARGF2 JITTER_ARGP2
49100 
49101 #else
49102   /* Define argument-access macros assuming that fast branches are disabled. */
49103     /* The 0th argument is a residual literal. */
49104 #if defined(JITTER_DISPATCH_NO_THREADING)
49105 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49106     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49107 #elif defined (JITTER_REPLICATE)
49108 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49109 #else
49110 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49111 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49112 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49113 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49114 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49115 #   define JITTER_ARGF0 JITTER_ARGP0
49116 
49117     /* The 1th argument is a residual literal. */
49118 #if defined(JITTER_DISPATCH_NO_THREADING)
49119 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
49120     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
49121 #elif defined (JITTER_REPLICATE)
49122 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
49123 #else
49124 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
49125 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49126 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
49127 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
49128 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
49129 #   define JITTER_ARGF1 JITTER_ARGP1
49130 
49131     /* The 2th argument is a residual label. */
49132 #if defined(JITTER_DISPATCH_NO_THREADING)
49133 #   define JITTER_ARG2  JITTER_RESIDUAL_ARGUMENT_2
49134     JITTER_MARK_RESIDUAL_2_AS_SET_BY_ASSEMBLY;
49135 #elif defined (JITTER_REPLICATE)
49136 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[2])
49137 #else
49138 #   define JITTER_ARG2  (((union jitter_word*)jitter_ip)[3])
49139 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49140 #   define JITTER_ARGN2 (JITTER_ARG2.fixnum)
49141 #   define JITTER_ARGU2 (JITTER_ARG2.ufixnum)
49142 #   define JITTER_ARGP2 (JITTER_ARG2.pointer)
49143 #   define JITTER_ARGF2 JITTER_ARGP2
49144 
49145 # endif // #ifdef JITTER_HAVE_PATCH_IN
49146 
49147 #ifdef JITTER_REPLICATE
49148     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
49149        it on the stack rather than in read-only memory.  I had to do this to prevent
49150        a GCC 8 snapshot on SH from being too clever. */
49151     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49152     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
49153        in memory, as a 16-bit constant; and since it reads it with a PC-relative
49154        load the relocated part crashes.
49155                  mov.w     .L1667,r0
49156                  mov.l     @(r0,r15),r1
49157                  jmp       @r1
49158        r15 is the stack pointer.  The constant at .L1667 is
49159           .L1667:
49160                  .short    232
49161        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
49162        can't work as an immediate.  Shall I keep these code pointers as a single array?
49163        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
49164        but the problem will be the same. */
49165     /* Jump to non-relocatable code. */
49166     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49167 
49168     /* Here the residual arity is given as zero: it's too late to
49169        skip residuals, since we've already jumped and this code is
49170        unreachable.  The instruction pointer, if any, is advanced
49171        in the non-relocatable code. */
49172     JITTER_INSTRUCTION_EPILOG_(*primitive/nR/nR/fR*-no-fast-branches, _Aprimitive__nR__nR__fR_A_mno_mfast_mbranches, 0)
49173 
49174     /* Relocated code will jump to this label in non-relocated code. */
49175   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
49176     JITTER_COMMENT_IN_ASM_("*primitive/nR/nR/fR*-no-fast-branches non-relocatable code");
49177 #endif // #ifdef JITTER_REPLICATE
49178 #if defined (JITTER_PROFILE_SAMPLE)
49179   JITTER_PROFILE_SAMPLE_UPDATE
49180      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49181       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49182   /* Force the compiler not move sample-profiling instrumentation
49183      beyond this point; this way the actual user code is timed.
49184      This is still not perfect, as residuals are materialised before
49185      we arrive here, but should be adequate at least for slow VM
49186      instructions. */
49187   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
49188 #endif
49189 #if defined (JITTER_PROFILE_COUNT)
49190   /* Notice that, differently from the code above, this
49191      instrumentation code *can* be reordered freely: as long as a
49192      VM instruction is counted, the count increment can be placed
49193      anyehere.  Let GCC move this code and possibly achieve better
49194      throughput by exploiting instruction-level parallelism and
49195      therefore approximate more closely a non-profiled build. */
49196   JITTER_PROFILE_COUNT_UPDATE
49197      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49198       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49199 #endif
49200 
49201 /* User-specified code, instruction-beginning-c part: beginning. */
49202 
49203 
49204 /* User-specified code, instruction-beginning-c part: end */
49205 
49206 
49207     /* User code for *primitive/nR/nR/fR*-no-fast-branches . */
49208 
49209     /* The error-handling label is not actually used in this case: the
49210        primitive function, written in C, has its own handling.  It's
49211        harmless to have it anyway, as it makes the C code generator
49212        more uniform. */
49213     jitterlisp_primitive_function p
49214       = (jitterlisp_primitive_function) JITTER_ARGP0;
49215     const jitter_uint in_arity = JITTER_ARGN1;
49216     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
49217     //asm volatile ("nop");
49218     jitterlisp_object *first_arg
49219       // FIXME: add a stack operator to compute this address.
49220       = (& JITTER_UNDER_TOP_MAINSTACK()) - in_arity + 1;
49221     /* This workaround is needed for Alpha.  I have macros to make this nicer in
49222        ~luca/repos/jitter/gcc-call-function-macro.c , still to be integrated into
49223        Jitter. */
49224 /*
49225     void *saved_gp;
49226     asm volatile ("stq $gp, %[saved_gp]"
49227                   : [saved_gp] "=o" (saved_gp),
49228                     "+X" (p));
49229 */
49230     jitterlisp_object res = p (first_arg);
49231     /* Second part of the Alpha workaround. */
49232 /*
49233     asm volatile ("ldq $gp, %[saved_gp]"
49234                   : "+X" (res)
49235                   : [saved_gp] "o" (saved_gp));
49236 */
49237 
49238     jitter_uint i;
49239     // Remove as many elements as the primitive in-arity, but not more:
49240     // the top unspecified value we pushed will be replaced with the result.
49241     for (i = 0; i < in_arity; i ++)
49242       JITTER_NIP_MAINSTACK();
49243     //asm ("unop" : "+g" (jitter_state_runtime));
49244     JITTER_TOP_MAINSTACK() = res;
49245 
49246     /* End of the user code for *primitive/nR/nR/fR*-no-fast-branches . */
49247 
49248 /* User-specified code, instruction-end-c part: beginning. */
49249 
49250 
49251 /* User-specified code, instruction-end-c part: end */
49252 
49253 #ifdef JITTER_REPLICATE
49254     /* Advance the instruction pointer, if any, to skip residuals;
49255        then jump back to replicated code. */
49256     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP2;
49257     JITTER_SKIP_RESIDUALS_;
49258     goto * _jitter_back_to_replicated_code_pointer;
49259 #endif // #ifdef JITTER_REPLICATE
49260 
49261     /* Undefine the *primitive/nR/nR/fR*-no-fast-branches argument macros so they can't be used
49262        by mistake in the instruction body coming next. */
49263 #   undef JITTER_SLOW_REGISTER_OFFSET0
49264 #   undef JITTER_ARG0
49265 #   undef JITTER_ARGN0
49266 #   undef JITTER_ARGU0
49267 #   undef JITTER_ARGP0
49268 #   undef JITTER_ARGF0
49269 #   undef JITTER_SLOW_REGISTER_OFFSET1
49270 #   undef JITTER_ARG1
49271 #   undef JITTER_ARGN1
49272 #   undef JITTER_ARGU1
49273 #   undef JITTER_ARGP1
49274 #   undef JITTER_ARGF1
49275 #   undef JITTER_SLOW_REGISTER_OFFSET2
49276 #   undef JITTER_ARG2
49277 #   undef JITTER_ARGN2
49278 #   undef JITTER_ARGU2
49279 #   undef JITTER_ARGP2
49280 #   undef JITTER_ARGF2
49281 
49282 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
49283 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
49284 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
49285 
49286   }
49287 #ifndef JITTER_REPLICATE
49288  JITTER_INSTRUCTION_EPILOG_(*primitive/nR/nR/fR*-no-fast-branches, _Aprimitive__nR__nR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
49289 #endif // #ifndef JITTER_REPLICATE
49290 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
49291 
49292   JITTER_INSTRUCTION_PROLOG_(*primitive-box-get/fR*-no-fast-branches, _Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches, hot)
49293   {
49294     /* This specialized instruction is a replacement. */
49295 #   undef JITTER_BRANCH_FAST
49296 #   define JITTER_BRANCH_FAST JITTER_BRANCH
49297 #   undef JITTER_BRANCH_FAST_IF_ZERO
49298 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
49299 #   undef JITTER_BRANCH_FAST_IF_NONZERO
49300 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
49301 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
49302 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
49303 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
49304 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
49305 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
49306 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
49307 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
49308 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
49309 #   undef JITTER_BRANCH_FAST_IF_EQUAL
49310 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
49311 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
49312 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
49313 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
49314 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
49315 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
49316 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
49317 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
49318 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
49319 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
49320 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
49321 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
49322 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
49323 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
49324 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
49325 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
49326 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
49327 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
49328 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
49329 #   undef JITTER_BRANCH_FAST_IF_AND
49330 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
49331 #   undef JITTER_BRANCH_FAST_IF_NOTAND
49332 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
49333 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
49334 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
49335 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
49336 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
49337 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
49338 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
49339 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
49340 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
49341 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
49342 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
49343 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
49344 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
49345 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
49346 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
49347 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
49348 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
49349 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
49350 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
49351 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
49352 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
49353 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
49354 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
49355 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
49356 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
49357 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
49358 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
49359     /* This specialized instruction is non-relocatable.
49360        Its 0-th argument, a literal, is the return address where to jump
49361        at the end, back to relocated code. */
49362 
49363 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       254
49364 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-box-get/fR*-no-fast-branches
49365 
49366 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches
49367 
49368   /* The residual arity for this instruction does not depend on fast labels. */
49369   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
49370 
49371   /* Define argument-access macros for *primitive-box-get/fR*-no-fast-branches . */
49372 #ifdef JITTER_HAVE_PATCH_IN
49373   /* Define argument-access macros assuming that fast branches are enabled. */
49374     /* The 0th argument is a residual label. */
49375 #if defined(JITTER_DISPATCH_NO_THREADING)
49376 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49377     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49378 #elif defined (JITTER_REPLICATE)
49379 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49380 #else
49381 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49382 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49383 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49384 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49385 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49386 #   define JITTER_ARGF0 JITTER_ARGP0
49387 
49388 #else
49389   /* Define argument-access macros assuming that fast branches are disabled. */
49390     /* The 0th argument is a residual label. */
49391 #if defined(JITTER_DISPATCH_NO_THREADING)
49392 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49393     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49394 #elif defined (JITTER_REPLICATE)
49395 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49396 #else
49397 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49398 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49399 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49400 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49401 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49402 #   define JITTER_ARGF0 JITTER_ARGP0
49403 
49404 # endif // #ifdef JITTER_HAVE_PATCH_IN
49405 
49406 #ifdef JITTER_REPLICATE
49407     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
49408        it on the stack rather than in read-only memory.  I had to do this to prevent
49409        a GCC 8 snapshot on SH from being too clever. */
49410     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49411     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
49412        in memory, as a 16-bit constant; and since it reads it with a PC-relative
49413        load the relocated part crashes.
49414                  mov.w     .L1667,r0
49415                  mov.l     @(r0,r15),r1
49416                  jmp       @r1
49417        r15 is the stack pointer.  The constant at .L1667 is
49418           .L1667:
49419                  .short    232
49420        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
49421        can't work as an immediate.  Shall I keep these code pointers as a single array?
49422        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
49423        but the problem will be the same. */
49424     /* Jump to non-relocatable code. */
49425     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49426 
49427     /* Here the residual arity is given as zero: it's too late to
49428        skip residuals, since we've already jumped and this code is
49429        unreachable.  The instruction pointer, if any, is advanced
49430        in the non-relocatable code. */
49431     JITTER_INSTRUCTION_EPILOG_(*primitive-box-get/fR*-no-fast-branches, _Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches, 0)
49432 
49433     /* Relocated code will jump to this label in non-relocated code. */
49434   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
49435     JITTER_COMMENT_IN_ASM_("*primitive-box-get/fR*-no-fast-branches non-relocatable code");
49436 #endif // #ifdef JITTER_REPLICATE
49437 #if defined (JITTER_PROFILE_SAMPLE)
49438   JITTER_PROFILE_SAMPLE_UPDATE
49439      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49440       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49441   /* Force the compiler not move sample-profiling instrumentation
49442      beyond this point; this way the actual user code is timed.
49443      This is still not perfect, as residuals are materialised before
49444      we arrive here, but should be adequate at least for slow VM
49445      instructions. */
49446   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
49447 #endif
49448 #if defined (JITTER_PROFILE_COUNT)
49449   /* Notice that, differently from the code above, this
49450      instrumentation code *can* be reordered freely: as long as a
49451      VM instruction is counted, the count increment can be placed
49452      anyehere.  Let GCC move this code and possibly achieve better
49453      throughput by exploiting instruction-level parallelism and
49454      therefore approximate more closely a non-profiled build. */
49455   JITTER_PROFILE_COUNT_UPDATE
49456      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49457       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49458 #endif
49459 
49460 /* User-specified code, instruction-beginning-c part: beginning. */
49461 
49462 
49463 /* User-specified code, instruction-beginning-c part: end */
49464 
49465 
49466     /* User code for *primitive-box-get/fR*-no-fast-branches . */
49467 
49468     JITTERLISPVM_CHECK_TYPES_1(BOX, JITTER_ARGF0);
49469     JITTERLISP_BOX_GET_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
49470 
49471     /* End of the user code for *primitive-box-get/fR*-no-fast-branches . */
49472 
49473 /* User-specified code, instruction-end-c part: beginning. */
49474 
49475 
49476 /* User-specified code, instruction-end-c part: end */
49477 
49478 #ifdef JITTER_REPLICATE
49479     /* Advance the instruction pointer, if any, to skip residuals;
49480        then jump back to replicated code. */
49481     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
49482     JITTER_SKIP_RESIDUALS_;
49483     goto * _jitter_back_to_replicated_code_pointer;
49484 #endif // #ifdef JITTER_REPLICATE
49485 
49486     /* Undefine the *primitive-box-get/fR*-no-fast-branches argument macros so they can't be used
49487        by mistake in the instruction body coming next. */
49488 #   undef JITTER_SLOW_REGISTER_OFFSET0
49489 #   undef JITTER_ARG0
49490 #   undef JITTER_ARGN0
49491 #   undef JITTER_ARGU0
49492 #   undef JITTER_ARGP0
49493 #   undef JITTER_ARGF0
49494 
49495 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
49496 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
49497 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
49498 
49499   }
49500 #ifndef JITTER_REPLICATE
49501  JITTER_INSTRUCTION_EPILOG_(*primitive-box-get/fR*-no-fast-branches, _Aprimitive_mbox_mget__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
49502 #endif // #ifndef JITTER_REPLICATE
49503 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
49504 
49505   JITTER_INSTRUCTION_PROLOG_(*primitive-box-setb-special/fR*-no-fast-branches, _Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches, hot)
49506   {
49507     /* This specialized instruction is a replacement. */
49508 #   undef JITTER_BRANCH_FAST
49509 #   define JITTER_BRANCH_FAST JITTER_BRANCH
49510 #   undef JITTER_BRANCH_FAST_IF_ZERO
49511 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
49512 #   undef JITTER_BRANCH_FAST_IF_NONZERO
49513 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
49514 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
49515 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
49516 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
49517 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
49518 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
49519 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
49520 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
49521 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
49522 #   undef JITTER_BRANCH_FAST_IF_EQUAL
49523 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
49524 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
49525 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
49526 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
49527 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
49528 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
49529 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
49530 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
49531 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
49532 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
49533 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
49534 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
49535 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
49536 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
49537 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
49538 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
49539 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
49540 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
49541 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
49542 #   undef JITTER_BRANCH_FAST_IF_AND
49543 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
49544 #   undef JITTER_BRANCH_FAST_IF_NOTAND
49545 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
49546 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
49547 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
49548 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
49549 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
49550 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
49551 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
49552 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
49553 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
49554 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
49555 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
49556 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
49557 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
49558 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
49559 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
49560 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
49561 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
49562 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
49563 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
49564 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
49565 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
49566 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
49567 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
49568 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
49569 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
49570 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
49571 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
49572     /* This specialized instruction is non-relocatable.
49573        Its 0-th argument, a literal, is the return address where to jump
49574        at the end, back to relocated code. */
49575 
49576 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       255
49577 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-box-setb-special/fR*-no-fast-branches
49578 
49579 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches
49580 
49581   /* The residual arity for this instruction does not depend on fast labels. */
49582   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
49583 
49584   /* Define argument-access macros for *primitive-box-setb-special/fR*-no-fast-branches . */
49585 #ifdef JITTER_HAVE_PATCH_IN
49586   /* Define argument-access macros assuming that fast branches are enabled. */
49587     /* The 0th argument is a residual label. */
49588 #if defined(JITTER_DISPATCH_NO_THREADING)
49589 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49590     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49591 #elif defined (JITTER_REPLICATE)
49592 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49593 #else
49594 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49595 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49596 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49597 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49598 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49599 #   define JITTER_ARGF0 JITTER_ARGP0
49600 
49601 #else
49602   /* Define argument-access macros assuming that fast branches are disabled. */
49603     /* The 0th argument is a residual label. */
49604 #if defined(JITTER_DISPATCH_NO_THREADING)
49605 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49606     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49607 #elif defined (JITTER_REPLICATE)
49608 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49609 #else
49610 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49611 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49612 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49613 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49614 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49615 #   define JITTER_ARGF0 JITTER_ARGP0
49616 
49617 # endif // #ifdef JITTER_HAVE_PATCH_IN
49618 
49619 #ifdef JITTER_REPLICATE
49620     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
49621        it on the stack rather than in read-only memory.  I had to do this to prevent
49622        a GCC 8 snapshot on SH from being too clever. */
49623     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49624     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
49625        in memory, as a 16-bit constant; and since it reads it with a PC-relative
49626        load the relocated part crashes.
49627                  mov.w     .L1667,r0
49628                  mov.l     @(r0,r15),r1
49629                  jmp       @r1
49630        r15 is the stack pointer.  The constant at .L1667 is
49631           .L1667:
49632                  .short    232
49633        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
49634        can't work as an immediate.  Shall I keep these code pointers as a single array?
49635        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
49636        but the problem will be the same. */
49637     /* Jump to non-relocatable code. */
49638     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49639 
49640     /* Here the residual arity is given as zero: it's too late to
49641        skip residuals, since we've already jumped and this code is
49642        unreachable.  The instruction pointer, if any, is advanced
49643        in the non-relocatable code. */
49644     JITTER_INSTRUCTION_EPILOG_(*primitive-box-setb-special/fR*-no-fast-branches, _Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches, 0)
49645 
49646     /* Relocated code will jump to this label in non-relocated code. */
49647   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
49648     JITTER_COMMENT_IN_ASM_("*primitive-box-setb-special/fR*-no-fast-branches non-relocatable code");
49649 #endif // #ifdef JITTER_REPLICATE
49650 #if defined (JITTER_PROFILE_SAMPLE)
49651   JITTER_PROFILE_SAMPLE_UPDATE
49652      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49653       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49654   /* Force the compiler not move sample-profiling instrumentation
49655      beyond this point; this way the actual user code is timed.
49656      This is still not perfect, as residuals are materialised before
49657      we arrive here, but should be adequate at least for slow VM
49658      instructions. */
49659   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
49660 #endif
49661 #if defined (JITTER_PROFILE_COUNT)
49662   /* Notice that, differently from the code above, this
49663      instrumentation code *can* be reordered freely: as long as a
49664      VM instruction is counted, the count increment can be placed
49665      anyehere.  Let GCC move this code and possibly achieve better
49666      throughput by exploiting instruction-level parallelism and
49667      therefore approximate more closely a non-profiled build. */
49668   JITTER_PROFILE_COUNT_UPDATE
49669      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49670       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49671 #endif
49672 
49673 /* User-specified code, instruction-beginning-c part: beginning. */
49674 
49675 
49676 /* User-specified code, instruction-beginning-c part: end */
49677 
49678 
49679     /* User code for *primitive-box-setb-special/fR*-no-fast-branches . */
49680 
49681     JITTERLISPVM_CHECK_TYPES_2(BOX, ANYTHING, JITTER_ARGF0);
49682     jitterlisp_object useless __attribute__ ((unused));
49683     JITTERLISP_BOX_SETB_(useless,
49684                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
49685     /* Leave the two operands on the stack. */
49686 
49687     /* End of the user code for *primitive-box-setb-special/fR*-no-fast-branches . */
49688 
49689 /* User-specified code, instruction-end-c part: beginning. */
49690 
49691 
49692 /* User-specified code, instruction-end-c part: end */
49693 
49694 #ifdef JITTER_REPLICATE
49695     /* Advance the instruction pointer, if any, to skip residuals;
49696        then jump back to replicated code. */
49697     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
49698     JITTER_SKIP_RESIDUALS_;
49699     goto * _jitter_back_to_replicated_code_pointer;
49700 #endif // #ifdef JITTER_REPLICATE
49701 
49702     /* Undefine the *primitive-box-setb-special/fR*-no-fast-branches argument macros so they can't be used
49703        by mistake in the instruction body coming next. */
49704 #   undef JITTER_SLOW_REGISTER_OFFSET0
49705 #   undef JITTER_ARG0
49706 #   undef JITTER_ARGN0
49707 #   undef JITTER_ARGU0
49708 #   undef JITTER_ARGP0
49709 #   undef JITTER_ARGF0
49710 
49711 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
49712 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
49713 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
49714 
49715   }
49716 #ifndef JITTER_REPLICATE
49717  JITTER_INSTRUCTION_EPILOG_(*primitive-box-setb-special/fR*-no-fast-branches, _Aprimitive_mbox_msetb_mspecial__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
49718 #endif // #ifndef JITTER_REPLICATE
49719 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
49720 
49721   JITTER_INSTRUCTION_PROLOG_(*primitive-car/fR*-no-fast-branches, _Aprimitive_mcar__fR_A_mno_mfast_mbranches, hot)
49722   {
49723     /* This specialized instruction is a replacement. */
49724 #   undef JITTER_BRANCH_FAST
49725 #   define JITTER_BRANCH_FAST JITTER_BRANCH
49726 #   undef JITTER_BRANCH_FAST_IF_ZERO
49727 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
49728 #   undef JITTER_BRANCH_FAST_IF_NONZERO
49729 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
49730 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
49731 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
49732 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
49733 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
49734 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
49735 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
49736 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
49737 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
49738 #   undef JITTER_BRANCH_FAST_IF_EQUAL
49739 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
49740 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
49741 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
49742 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
49743 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
49744 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
49745 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
49746 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
49747 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
49748 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
49749 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
49750 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
49751 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
49752 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
49753 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
49754 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
49755 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
49756 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
49757 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
49758 #   undef JITTER_BRANCH_FAST_IF_AND
49759 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
49760 #   undef JITTER_BRANCH_FAST_IF_NOTAND
49761 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
49762 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
49763 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
49764 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
49765 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
49766 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
49767 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
49768 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
49769 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
49770 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
49771 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
49772 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
49773 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
49774 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
49775 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
49776 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
49777 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
49778 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
49779 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
49780 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
49781 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
49782 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
49783 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
49784 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
49785 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
49786 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
49787 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
49788     /* This specialized instruction is non-relocatable.
49789        Its 0-th argument, a literal, is the return address where to jump
49790        at the end, back to relocated code. */
49791 
49792 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       256
49793 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-car/fR*-no-fast-branches
49794 
49795 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mcar__fR_A_mno_mfast_mbranches
49796 
49797   /* The residual arity for this instruction does not depend on fast labels. */
49798   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
49799 
49800   /* Define argument-access macros for *primitive-car/fR*-no-fast-branches . */
49801 #ifdef JITTER_HAVE_PATCH_IN
49802   /* Define argument-access macros assuming that fast branches are enabled. */
49803     /* The 0th argument is a residual label. */
49804 #if defined(JITTER_DISPATCH_NO_THREADING)
49805 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49806     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49807 #elif defined (JITTER_REPLICATE)
49808 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49809 #else
49810 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49811 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49812 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49813 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49814 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49815 #   define JITTER_ARGF0 JITTER_ARGP0
49816 
49817 #else
49818   /* Define argument-access macros assuming that fast branches are disabled. */
49819     /* The 0th argument is a residual label. */
49820 #if defined(JITTER_DISPATCH_NO_THREADING)
49821 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
49822     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
49823 #elif defined (JITTER_REPLICATE)
49824 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
49825 #else
49826 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
49827 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
49828 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
49829 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
49830 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
49831 #   define JITTER_ARGF0 JITTER_ARGP0
49832 
49833 # endif // #ifdef JITTER_HAVE_PATCH_IN
49834 
49835 #ifdef JITTER_REPLICATE
49836     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
49837        it on the stack rather than in read-only memory.  I had to do this to prevent
49838        a GCC 8 snapshot on SH from being too clever. */
49839     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49840     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
49841        in memory, as a 16-bit constant; and since it reads it with a PC-relative
49842        load the relocated part crashes.
49843                  mov.w     .L1667,r0
49844                  mov.l     @(r0,r15),r1
49845                  jmp       @r1
49846        r15 is the stack pointer.  The constant at .L1667 is
49847           .L1667:
49848                  .short    232
49849        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
49850        can't work as an immediate.  Shall I keep these code pointers as a single array?
49851        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
49852        but the problem will be the same. */
49853     /* Jump to non-relocatable code. */
49854     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
49855 
49856     /* Here the residual arity is given as zero: it's too late to
49857        skip residuals, since we've already jumped and this code is
49858        unreachable.  The instruction pointer, if any, is advanced
49859        in the non-relocatable code. */
49860     JITTER_INSTRUCTION_EPILOG_(*primitive-car/fR*-no-fast-branches, _Aprimitive_mcar__fR_A_mno_mfast_mbranches, 0)
49861 
49862     /* Relocated code will jump to this label in non-relocated code. */
49863   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
49864     JITTER_COMMENT_IN_ASM_("*primitive-car/fR*-no-fast-branches non-relocatable code");
49865 #endif // #ifdef JITTER_REPLICATE
49866 #if defined (JITTER_PROFILE_SAMPLE)
49867   JITTER_PROFILE_SAMPLE_UPDATE
49868      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49869       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49870   /* Force the compiler not move sample-profiling instrumentation
49871      beyond this point; this way the actual user code is timed.
49872      This is still not perfect, as residuals are materialised before
49873      we arrive here, but should be adequate at least for slow VM
49874      instructions. */
49875   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
49876 #endif
49877 #if defined (JITTER_PROFILE_COUNT)
49878   /* Notice that, differently from the code above, this
49879      instrumentation code *can* be reordered freely: as long as a
49880      VM instruction is counted, the count increment can be placed
49881      anyehere.  Let GCC move this code and possibly achieve better
49882      throughput by exploiting instruction-level parallelism and
49883      therefore approximate more closely a non-profiled build. */
49884   JITTER_PROFILE_COUNT_UPDATE
49885      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
49886       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
49887 #endif
49888 
49889 /* User-specified code, instruction-beginning-c part: beginning. */
49890 
49891 
49892 /* User-specified code, instruction-beginning-c part: end */
49893 
49894 
49895     /* User code for *primitive-car/fR*-no-fast-branches . */
49896 
49897     JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
49898     JITTERLISP_CAR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
49899 
49900     /* End of the user code for *primitive-car/fR*-no-fast-branches . */
49901 
49902 /* User-specified code, instruction-end-c part: beginning. */
49903 
49904 
49905 /* User-specified code, instruction-end-c part: end */
49906 
49907 #ifdef JITTER_REPLICATE
49908     /* Advance the instruction pointer, if any, to skip residuals;
49909        then jump back to replicated code. */
49910     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
49911     JITTER_SKIP_RESIDUALS_;
49912     goto * _jitter_back_to_replicated_code_pointer;
49913 #endif // #ifdef JITTER_REPLICATE
49914 
49915     /* Undefine the *primitive-car/fR*-no-fast-branches argument macros so they can't be used
49916        by mistake in the instruction body coming next. */
49917 #   undef JITTER_SLOW_REGISTER_OFFSET0
49918 #   undef JITTER_ARG0
49919 #   undef JITTER_ARGN0
49920 #   undef JITTER_ARGU0
49921 #   undef JITTER_ARGP0
49922 #   undef JITTER_ARGF0
49923 
49924 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
49925 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
49926 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
49927 
49928   }
49929 #ifndef JITTER_REPLICATE
49930  JITTER_INSTRUCTION_EPILOG_(*primitive-car/fR*-no-fast-branches, _Aprimitive_mcar__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
49931 #endif // #ifndef JITTER_REPLICATE
49932 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
49933 
49934   JITTER_INSTRUCTION_PROLOG_(*primitive-cdr/fR*-no-fast-branches, _Aprimitive_mcdr__fR_A_mno_mfast_mbranches, hot)
49935   {
49936     /* This specialized instruction is a replacement. */
49937 #   undef JITTER_BRANCH_FAST
49938 #   define JITTER_BRANCH_FAST JITTER_BRANCH
49939 #   undef JITTER_BRANCH_FAST_IF_ZERO
49940 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
49941 #   undef JITTER_BRANCH_FAST_IF_NONZERO
49942 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
49943 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
49944 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
49945 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
49946 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
49947 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
49948 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
49949 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
49950 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
49951 #   undef JITTER_BRANCH_FAST_IF_EQUAL
49952 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
49953 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
49954 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
49955 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
49956 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
49957 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
49958 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
49959 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
49960 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
49961 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
49962 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
49963 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
49964 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
49965 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
49966 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
49967 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
49968 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
49969 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
49970 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
49971 #   undef JITTER_BRANCH_FAST_IF_AND
49972 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
49973 #   undef JITTER_BRANCH_FAST_IF_NOTAND
49974 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
49975 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
49976 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
49977 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
49978 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
49979 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
49980 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
49981 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
49982 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
49983 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
49984 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
49985 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
49986 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
49987 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
49988 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
49989 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
49990 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
49991 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
49992 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
49993 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
49994 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
49995 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
49996 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
49997 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
49998 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
49999 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
50000 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
50001     /* This specialized instruction is non-relocatable.
50002        Its 0-th argument, a literal, is the return address where to jump
50003        at the end, back to relocated code. */
50004 
50005 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       257
50006 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-cdr/fR*-no-fast-branches
50007 
50008 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mcdr__fR_A_mno_mfast_mbranches
50009 
50010   /* The residual arity for this instruction does not depend on fast labels. */
50011   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
50012 
50013   /* Define argument-access macros for *primitive-cdr/fR*-no-fast-branches . */
50014 #ifdef JITTER_HAVE_PATCH_IN
50015   /* Define argument-access macros assuming that fast branches are enabled. */
50016     /* The 0th argument is a residual label. */
50017 #if defined(JITTER_DISPATCH_NO_THREADING)
50018 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50019     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50020 #elif defined (JITTER_REPLICATE)
50021 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50022 #else
50023 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50024 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50025 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50026 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50027 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50028 #   define JITTER_ARGF0 JITTER_ARGP0
50029 
50030 #else
50031   /* Define argument-access macros assuming that fast branches are disabled. */
50032     /* The 0th argument is a residual label. */
50033 #if defined(JITTER_DISPATCH_NO_THREADING)
50034 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50035     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50036 #elif defined (JITTER_REPLICATE)
50037 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50038 #else
50039 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50040 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50041 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50042 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50043 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50044 #   define JITTER_ARGF0 JITTER_ARGP0
50045 
50046 # endif // #ifdef JITTER_HAVE_PATCH_IN
50047 
50048 #ifdef JITTER_REPLICATE
50049     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
50050        it on the stack rather than in read-only memory.  I had to do this to prevent
50051        a GCC 8 snapshot on SH from being too clever. */
50052     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50053     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
50054        in memory, as a 16-bit constant; and since it reads it with a PC-relative
50055        load the relocated part crashes.
50056                  mov.w     .L1667,r0
50057                  mov.l     @(r0,r15),r1
50058                  jmp       @r1
50059        r15 is the stack pointer.  The constant at .L1667 is
50060           .L1667:
50061                  .short    232
50062        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
50063        can't work as an immediate.  Shall I keep these code pointers as a single array?
50064        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
50065        but the problem will be the same. */
50066     /* Jump to non-relocatable code. */
50067     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50068 
50069     /* Here the residual arity is given as zero: it's too late to
50070        skip residuals, since we've already jumped and this code is
50071        unreachable.  The instruction pointer, if any, is advanced
50072        in the non-relocatable code. */
50073     JITTER_INSTRUCTION_EPILOG_(*primitive-cdr/fR*-no-fast-branches, _Aprimitive_mcdr__fR_A_mno_mfast_mbranches, 0)
50074 
50075     /* Relocated code will jump to this label in non-relocated code. */
50076   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
50077     JITTER_COMMENT_IN_ASM_("*primitive-cdr/fR*-no-fast-branches non-relocatable code");
50078 #endif // #ifdef JITTER_REPLICATE
50079 #if defined (JITTER_PROFILE_SAMPLE)
50080   JITTER_PROFILE_SAMPLE_UPDATE
50081      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50082       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50083   /* Force the compiler not move sample-profiling instrumentation
50084      beyond this point; this way the actual user code is timed.
50085      This is still not perfect, as residuals are materialised before
50086      we arrive here, but should be adequate at least for slow VM
50087      instructions. */
50088   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
50089 #endif
50090 #if defined (JITTER_PROFILE_COUNT)
50091   /* Notice that, differently from the code above, this
50092      instrumentation code *can* be reordered freely: as long as a
50093      VM instruction is counted, the count increment can be placed
50094      anyehere.  Let GCC move this code and possibly achieve better
50095      throughput by exploiting instruction-level parallelism and
50096      therefore approximate more closely a non-profiled build. */
50097   JITTER_PROFILE_COUNT_UPDATE
50098      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50099       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50100 #endif
50101 
50102 /* User-specified code, instruction-beginning-c part: beginning. */
50103 
50104 
50105 /* User-specified code, instruction-beginning-c part: end */
50106 
50107 
50108     /* User code for *primitive-cdr/fR*-no-fast-branches . */
50109 
50110     JITTERLISPVM_CHECK_TYPES_1(CONS, JITTER_ARGF0);
50111     JITTERLISP_CDR_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
50112 
50113     /* End of the user code for *primitive-cdr/fR*-no-fast-branches . */
50114 
50115 /* User-specified code, instruction-end-c part: beginning. */
50116 
50117 
50118 /* User-specified code, instruction-end-c part: end */
50119 
50120 #ifdef JITTER_REPLICATE
50121     /* Advance the instruction pointer, if any, to skip residuals;
50122        then jump back to replicated code. */
50123     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
50124     JITTER_SKIP_RESIDUALS_;
50125     goto * _jitter_back_to_replicated_code_pointer;
50126 #endif // #ifdef JITTER_REPLICATE
50127 
50128     /* Undefine the *primitive-cdr/fR*-no-fast-branches argument macros so they can't be used
50129        by mistake in the instruction body coming next. */
50130 #   undef JITTER_SLOW_REGISTER_OFFSET0
50131 #   undef JITTER_ARG0
50132 #   undef JITTER_ARGN0
50133 #   undef JITTER_ARGU0
50134 #   undef JITTER_ARGP0
50135 #   undef JITTER_ARGF0
50136 
50137 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
50138 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
50139 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
50140 
50141   }
50142 #ifndef JITTER_REPLICATE
50143  JITTER_INSTRUCTION_EPILOG_(*primitive-cdr/fR*-no-fast-branches, _Aprimitive_mcdr__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
50144 #endif // #ifndef JITTER_REPLICATE
50145 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
50146 
50147   JITTER_INSTRUCTION_PROLOG_(*primitive-fixnum-eqp/fR*-no-fast-branches, _Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches, hot)
50148   {
50149     /* This specialized instruction is a replacement. */
50150 #   undef JITTER_BRANCH_FAST
50151 #   define JITTER_BRANCH_FAST JITTER_BRANCH
50152 #   undef JITTER_BRANCH_FAST_IF_ZERO
50153 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
50154 #   undef JITTER_BRANCH_FAST_IF_NONZERO
50155 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
50156 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
50157 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
50158 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
50159 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
50160 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
50161 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
50162 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
50163 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
50164 #   undef JITTER_BRANCH_FAST_IF_EQUAL
50165 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
50166 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
50167 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
50168 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
50169 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
50170 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
50171 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
50172 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
50173 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
50174 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
50175 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
50176 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
50177 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
50178 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
50179 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
50180 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
50181 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
50182 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
50183 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
50184 #   undef JITTER_BRANCH_FAST_IF_AND
50185 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
50186 #   undef JITTER_BRANCH_FAST_IF_NOTAND
50187 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
50188 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
50189 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
50190 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
50191 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
50192 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
50193 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
50194 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
50195 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
50196 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
50197 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
50198 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
50199 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
50200 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
50201 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
50202 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
50203 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
50204 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
50205 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
50206 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
50207 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
50208 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
50209 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
50210 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
50211 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
50212 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
50213 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
50214     /* This specialized instruction is non-relocatable.
50215        Its 0-th argument, a literal, is the return address where to jump
50216        at the end, back to relocated code. */
50217 
50218 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       258
50219 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-fixnum-eqp/fR*-no-fast-branches
50220 
50221 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches
50222 
50223   /* The residual arity for this instruction does not depend on fast labels. */
50224   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
50225 
50226   /* Define argument-access macros for *primitive-fixnum-eqp/fR*-no-fast-branches . */
50227 #ifdef JITTER_HAVE_PATCH_IN
50228   /* Define argument-access macros assuming that fast branches are enabled. */
50229     /* The 0th argument is a residual label. */
50230 #if defined(JITTER_DISPATCH_NO_THREADING)
50231 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50232     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50233 #elif defined (JITTER_REPLICATE)
50234 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50235 #else
50236 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50237 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50238 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50239 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50240 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50241 #   define JITTER_ARGF0 JITTER_ARGP0
50242 
50243 #else
50244   /* Define argument-access macros assuming that fast branches are disabled. */
50245     /* The 0th argument is a residual label. */
50246 #if defined(JITTER_DISPATCH_NO_THREADING)
50247 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50248     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50249 #elif defined (JITTER_REPLICATE)
50250 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50251 #else
50252 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50253 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50254 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50255 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50256 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50257 #   define JITTER_ARGF0 JITTER_ARGP0
50258 
50259 # endif // #ifdef JITTER_HAVE_PATCH_IN
50260 
50261 #ifdef JITTER_REPLICATE
50262     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
50263        it on the stack rather than in read-only memory.  I had to do this to prevent
50264        a GCC 8 snapshot on SH from being too clever. */
50265     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50266     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
50267        in memory, as a 16-bit constant; and since it reads it with a PC-relative
50268        load the relocated part crashes.
50269                  mov.w     .L1667,r0
50270                  mov.l     @(r0,r15),r1
50271                  jmp       @r1
50272        r15 is the stack pointer.  The constant at .L1667 is
50273           .L1667:
50274                  .short    232
50275        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
50276        can't work as an immediate.  Shall I keep these code pointers as a single array?
50277        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
50278        but the problem will be the same. */
50279     /* Jump to non-relocatable code. */
50280     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50281 
50282     /* Here the residual arity is given as zero: it's too late to
50283        skip residuals, since we've already jumped and this code is
50284        unreachable.  The instruction pointer, if any, is advanced
50285        in the non-relocatable code. */
50286     JITTER_INSTRUCTION_EPILOG_(*primitive-fixnum-eqp/fR*-no-fast-branches, _Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches, 0)
50287 
50288     /* Relocated code will jump to this label in non-relocated code. */
50289   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
50290     JITTER_COMMENT_IN_ASM_("*primitive-fixnum-eqp/fR*-no-fast-branches non-relocatable code");
50291 #endif // #ifdef JITTER_REPLICATE
50292 #if defined (JITTER_PROFILE_SAMPLE)
50293   JITTER_PROFILE_SAMPLE_UPDATE
50294      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50295       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50296   /* Force the compiler not move sample-profiling instrumentation
50297      beyond this point; this way the actual user code is timed.
50298      This is still not perfect, as residuals are materialised before
50299      we arrive here, but should be adequate at least for slow VM
50300      instructions. */
50301   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
50302 #endif
50303 #if defined (JITTER_PROFILE_COUNT)
50304   /* Notice that, differently from the code above, this
50305      instrumentation code *can* be reordered freely: as long as a
50306      VM instruction is counted, the count increment can be placed
50307      anyehere.  Let GCC move this code and possibly achieve better
50308      throughput by exploiting instruction-level parallelism and
50309      therefore approximate more closely a non-profiled build. */
50310   JITTER_PROFILE_COUNT_UPDATE
50311      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50312       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50313 #endif
50314 
50315 /* User-specified code, instruction-beginning-c part: beginning. */
50316 
50317 
50318 /* User-specified code, instruction-beginning-c part: end */
50319 
50320 
50321     /* User code for *primitive-fixnum-eqp/fR*-no-fast-branches . */
50322 
50323     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
50324     JITTERLISP_EQP_(JITTER_TOP_MAINSTACK(),
50325                     JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
50326     JITTER_NIP_MAINSTACK();
50327 
50328     /* End of the user code for *primitive-fixnum-eqp/fR*-no-fast-branches . */
50329 
50330 /* User-specified code, instruction-end-c part: beginning. */
50331 
50332 
50333 /* User-specified code, instruction-end-c part: end */
50334 
50335 #ifdef JITTER_REPLICATE
50336     /* Advance the instruction pointer, if any, to skip residuals;
50337        then jump back to replicated code. */
50338     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
50339     JITTER_SKIP_RESIDUALS_;
50340     goto * _jitter_back_to_replicated_code_pointer;
50341 #endif // #ifdef JITTER_REPLICATE
50342 
50343     /* Undefine the *primitive-fixnum-eqp/fR*-no-fast-branches argument macros so they can't be used
50344        by mistake in the instruction body coming next. */
50345 #   undef JITTER_SLOW_REGISTER_OFFSET0
50346 #   undef JITTER_ARG0
50347 #   undef JITTER_ARGN0
50348 #   undef JITTER_ARGU0
50349 #   undef JITTER_ARGP0
50350 #   undef JITTER_ARGF0
50351 
50352 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
50353 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
50354 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
50355 
50356   }
50357 #ifndef JITTER_REPLICATE
50358  JITTER_INSTRUCTION_EPILOG_(*primitive-fixnum-eqp/fR*-no-fast-branches, _Aprimitive_mfixnum_meqp__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
50359 #endif // #ifndef JITTER_REPLICATE
50360 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
50361 
50362   JITTER_INSTRUCTION_PROLOG_(*primitive-fixnum-not-eqp/fR*-no-fast-branches, _Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches, hot)
50363   {
50364     /* This specialized instruction is a replacement. */
50365 #   undef JITTER_BRANCH_FAST
50366 #   define JITTER_BRANCH_FAST JITTER_BRANCH
50367 #   undef JITTER_BRANCH_FAST_IF_ZERO
50368 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
50369 #   undef JITTER_BRANCH_FAST_IF_NONZERO
50370 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
50371 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
50372 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
50373 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
50374 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
50375 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
50376 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
50377 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
50378 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
50379 #   undef JITTER_BRANCH_FAST_IF_EQUAL
50380 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
50381 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
50382 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
50383 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
50384 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
50385 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
50386 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
50387 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
50388 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
50389 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
50390 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
50391 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
50392 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
50393 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
50394 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
50395 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
50396 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
50397 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
50398 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
50399 #   undef JITTER_BRANCH_FAST_IF_AND
50400 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
50401 #   undef JITTER_BRANCH_FAST_IF_NOTAND
50402 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
50403 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
50404 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
50405 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
50406 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
50407 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
50408 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
50409 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
50410 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
50411 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
50412 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
50413 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
50414 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
50415 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
50416 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
50417 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
50418 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
50419 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
50420 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
50421 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
50422 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
50423 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
50424 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
50425 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
50426 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
50427 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
50428 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
50429     /* This specialized instruction is non-relocatable.
50430        Its 0-th argument, a literal, is the return address where to jump
50431        at the end, back to relocated code. */
50432 
50433 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       259
50434 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-fixnum-not-eqp/fR*-no-fast-branches
50435 
50436 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches
50437 
50438   /* The residual arity for this instruction does not depend on fast labels. */
50439   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
50440 
50441   /* Define argument-access macros for *primitive-fixnum-not-eqp/fR*-no-fast-branches . */
50442 #ifdef JITTER_HAVE_PATCH_IN
50443   /* Define argument-access macros assuming that fast branches are enabled. */
50444     /* The 0th argument is a residual label. */
50445 #if defined(JITTER_DISPATCH_NO_THREADING)
50446 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50447     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50448 #elif defined (JITTER_REPLICATE)
50449 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50450 #else
50451 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50452 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50453 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50454 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50455 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50456 #   define JITTER_ARGF0 JITTER_ARGP0
50457 
50458 #else
50459   /* Define argument-access macros assuming that fast branches are disabled. */
50460     /* The 0th argument is a residual label. */
50461 #if defined(JITTER_DISPATCH_NO_THREADING)
50462 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50463     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50464 #elif defined (JITTER_REPLICATE)
50465 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50466 #else
50467 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50468 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50469 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50470 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50471 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50472 #   define JITTER_ARGF0 JITTER_ARGP0
50473 
50474 # endif // #ifdef JITTER_HAVE_PATCH_IN
50475 
50476 #ifdef JITTER_REPLICATE
50477     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
50478        it on the stack rather than in read-only memory.  I had to do this to prevent
50479        a GCC 8 snapshot on SH from being too clever. */
50480     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50481     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
50482        in memory, as a 16-bit constant; and since it reads it with a PC-relative
50483        load the relocated part crashes.
50484                  mov.w     .L1667,r0
50485                  mov.l     @(r0,r15),r1
50486                  jmp       @r1
50487        r15 is the stack pointer.  The constant at .L1667 is
50488           .L1667:
50489                  .short    232
50490        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
50491        can't work as an immediate.  Shall I keep these code pointers as a single array?
50492        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
50493        but the problem will be the same. */
50494     /* Jump to non-relocatable code. */
50495     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50496 
50497     /* Here the residual arity is given as zero: it's too late to
50498        skip residuals, since we've already jumped and this code is
50499        unreachable.  The instruction pointer, if any, is advanced
50500        in the non-relocatable code. */
50501     JITTER_INSTRUCTION_EPILOG_(*primitive-fixnum-not-eqp/fR*-no-fast-branches, _Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches, 0)
50502 
50503     /* Relocated code will jump to this label in non-relocated code. */
50504   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
50505     JITTER_COMMENT_IN_ASM_("*primitive-fixnum-not-eqp/fR*-no-fast-branches non-relocatable code");
50506 #endif // #ifdef JITTER_REPLICATE
50507 #if defined (JITTER_PROFILE_SAMPLE)
50508   JITTER_PROFILE_SAMPLE_UPDATE
50509      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50510       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50511   /* Force the compiler not move sample-profiling instrumentation
50512      beyond this point; this way the actual user code is timed.
50513      This is still not perfect, as residuals are materialised before
50514      we arrive here, but should be adequate at least for slow VM
50515      instructions. */
50516   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
50517 #endif
50518 #if defined (JITTER_PROFILE_COUNT)
50519   /* Notice that, differently from the code above, this
50520      instrumentation code *can* be reordered freely: as long as a
50521      VM instruction is counted, the count increment can be placed
50522      anyehere.  Let GCC move this code and possibly achieve better
50523      throughput by exploiting instruction-level parallelism and
50524      therefore approximate more closely a non-profiled build. */
50525   JITTER_PROFILE_COUNT_UPDATE
50526      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50527       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50528 #endif
50529 
50530 /* User-specified code, instruction-beginning-c part: beginning. */
50531 
50532 
50533 /* User-specified code, instruction-beginning-c part: end */
50534 
50535 
50536     /* User code for *primitive-fixnum-not-eqp/fR*-no-fast-branches . */
50537 
50538     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
50539     JITTERLISP_NOT_EQP_(JITTER_TOP_MAINSTACK(),
50540                         JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
50541     JITTER_NIP_MAINSTACK();
50542 
50543     /* End of the user code for *primitive-fixnum-not-eqp/fR*-no-fast-branches . */
50544 
50545 /* User-specified code, instruction-end-c part: beginning. */
50546 
50547 
50548 /* User-specified code, instruction-end-c part: end */
50549 
50550 #ifdef JITTER_REPLICATE
50551     /* Advance the instruction pointer, if any, to skip residuals;
50552        then jump back to replicated code. */
50553     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
50554     JITTER_SKIP_RESIDUALS_;
50555     goto * _jitter_back_to_replicated_code_pointer;
50556 #endif // #ifdef JITTER_REPLICATE
50557 
50558     /* Undefine the *primitive-fixnum-not-eqp/fR*-no-fast-branches argument macros so they can't be used
50559        by mistake in the instruction body coming next. */
50560 #   undef JITTER_SLOW_REGISTER_OFFSET0
50561 #   undef JITTER_ARG0
50562 #   undef JITTER_ARGN0
50563 #   undef JITTER_ARGU0
50564 #   undef JITTER_ARGP0
50565 #   undef JITTER_ARGF0
50566 
50567 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
50568 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
50569 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
50570 
50571   }
50572 #ifndef JITTER_REPLICATE
50573  JITTER_INSTRUCTION_EPILOG_(*primitive-fixnum-not-eqp/fR*-no-fast-branches, _Aprimitive_mfixnum_mnot_meqp__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
50574 #endif // #ifndef JITTER_REPLICATE
50575 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
50576 
50577   JITTER_INSTRUCTION_PROLOG_(*primitive-greaterp/fR*-no-fast-branches, _Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches, hot)
50578   {
50579     /* This specialized instruction is a replacement. */
50580 #   undef JITTER_BRANCH_FAST
50581 #   define JITTER_BRANCH_FAST JITTER_BRANCH
50582 #   undef JITTER_BRANCH_FAST_IF_ZERO
50583 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
50584 #   undef JITTER_BRANCH_FAST_IF_NONZERO
50585 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
50586 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
50587 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
50588 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
50589 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
50590 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
50591 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
50592 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
50593 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
50594 #   undef JITTER_BRANCH_FAST_IF_EQUAL
50595 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
50596 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
50597 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
50598 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
50599 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
50600 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
50601 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
50602 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
50603 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
50604 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
50605 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
50606 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
50607 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
50608 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
50609 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
50610 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
50611 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
50612 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
50613 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
50614 #   undef JITTER_BRANCH_FAST_IF_AND
50615 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
50616 #   undef JITTER_BRANCH_FAST_IF_NOTAND
50617 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
50618 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
50619 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
50620 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
50621 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
50622 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
50623 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
50624 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
50625 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
50626 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
50627 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
50628 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
50629 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
50630 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
50631 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
50632 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
50633 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
50634 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
50635 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
50636 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
50637 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
50638 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
50639 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
50640 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
50641 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
50642 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
50643 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
50644     /* This specialized instruction is non-relocatable.
50645        Its 0-th argument, a literal, is the return address where to jump
50646        at the end, back to relocated code. */
50647 
50648 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       260
50649 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-greaterp/fR*-no-fast-branches
50650 
50651 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches
50652 
50653   /* The residual arity for this instruction does not depend on fast labels. */
50654   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
50655 
50656   /* Define argument-access macros for *primitive-greaterp/fR*-no-fast-branches . */
50657 #ifdef JITTER_HAVE_PATCH_IN
50658   /* Define argument-access macros assuming that fast branches are enabled. */
50659     /* The 0th argument is a residual label. */
50660 #if defined(JITTER_DISPATCH_NO_THREADING)
50661 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50662     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50663 #elif defined (JITTER_REPLICATE)
50664 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50665 #else
50666 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50667 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50668 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50669 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50670 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50671 #   define JITTER_ARGF0 JITTER_ARGP0
50672 
50673 #else
50674   /* Define argument-access macros assuming that fast branches are disabled. */
50675     /* The 0th argument is a residual label. */
50676 #if defined(JITTER_DISPATCH_NO_THREADING)
50677 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50678     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50679 #elif defined (JITTER_REPLICATE)
50680 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50681 #else
50682 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50683 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50684 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50685 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50686 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50687 #   define JITTER_ARGF0 JITTER_ARGP0
50688 
50689 # endif // #ifdef JITTER_HAVE_PATCH_IN
50690 
50691 #ifdef JITTER_REPLICATE
50692     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
50693        it on the stack rather than in read-only memory.  I had to do this to prevent
50694        a GCC 8 snapshot on SH from being too clever. */
50695     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50696     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
50697        in memory, as a 16-bit constant; and since it reads it with a PC-relative
50698        load the relocated part crashes.
50699                  mov.w     .L1667,r0
50700                  mov.l     @(r0,r15),r1
50701                  jmp       @r1
50702        r15 is the stack pointer.  The constant at .L1667 is
50703           .L1667:
50704                  .short    232
50705        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
50706        can't work as an immediate.  Shall I keep these code pointers as a single array?
50707        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
50708        but the problem will be the same. */
50709     /* Jump to non-relocatable code. */
50710     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50711 
50712     /* Here the residual arity is given as zero: it's too late to
50713        skip residuals, since we've already jumped and this code is
50714        unreachable.  The instruction pointer, if any, is advanced
50715        in the non-relocatable code. */
50716     JITTER_INSTRUCTION_EPILOG_(*primitive-greaterp/fR*-no-fast-branches, _Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches, 0)
50717 
50718     /* Relocated code will jump to this label in non-relocated code. */
50719   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
50720     JITTER_COMMENT_IN_ASM_("*primitive-greaterp/fR*-no-fast-branches non-relocatable code");
50721 #endif // #ifdef JITTER_REPLICATE
50722 #if defined (JITTER_PROFILE_SAMPLE)
50723   JITTER_PROFILE_SAMPLE_UPDATE
50724      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50725       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50726   /* Force the compiler not move sample-profiling instrumentation
50727      beyond this point; this way the actual user code is timed.
50728      This is still not perfect, as residuals are materialised before
50729      we arrive here, but should be adequate at least for slow VM
50730      instructions. */
50731   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
50732 #endif
50733 #if defined (JITTER_PROFILE_COUNT)
50734   /* Notice that, differently from the code above, this
50735      instrumentation code *can* be reordered freely: as long as a
50736      VM instruction is counted, the count increment can be placed
50737      anyehere.  Let GCC move this code and possibly achieve better
50738      throughput by exploiting instruction-level parallelism and
50739      therefore approximate more closely a non-profiled build. */
50740   JITTER_PROFILE_COUNT_UPDATE
50741      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50742       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50743 #endif
50744 
50745 /* User-specified code, instruction-beginning-c part: beginning. */
50746 
50747 
50748 /* User-specified code, instruction-beginning-c part: end */
50749 
50750 
50751     /* User code for *primitive-greaterp/fR*-no-fast-branches . */
50752 
50753     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
50754     JITTERLISP_GREATERP_(JITTER_TOP_MAINSTACK(),
50755                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
50756     JITTER_NIP_MAINSTACK();
50757 
50758     /* End of the user code for *primitive-greaterp/fR*-no-fast-branches . */
50759 
50760 /* User-specified code, instruction-end-c part: beginning. */
50761 
50762 
50763 /* User-specified code, instruction-end-c part: end */
50764 
50765 #ifdef JITTER_REPLICATE
50766     /* Advance the instruction pointer, if any, to skip residuals;
50767        then jump back to replicated code. */
50768     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
50769     JITTER_SKIP_RESIDUALS_;
50770     goto * _jitter_back_to_replicated_code_pointer;
50771 #endif // #ifdef JITTER_REPLICATE
50772 
50773     /* Undefine the *primitive-greaterp/fR*-no-fast-branches argument macros so they can't be used
50774        by mistake in the instruction body coming next. */
50775 #   undef JITTER_SLOW_REGISTER_OFFSET0
50776 #   undef JITTER_ARG0
50777 #   undef JITTER_ARGN0
50778 #   undef JITTER_ARGU0
50779 #   undef JITTER_ARGP0
50780 #   undef JITTER_ARGF0
50781 
50782 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
50783 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
50784 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
50785 
50786   }
50787 #ifndef JITTER_REPLICATE
50788  JITTER_INSTRUCTION_EPILOG_(*primitive-greaterp/fR*-no-fast-branches, _Aprimitive_mgreaterp__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
50789 #endif // #ifndef JITTER_REPLICATE
50790 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
50791 
50792   JITTER_INSTRUCTION_PROLOG_(*primitive-lessp/fR*-no-fast-branches, _Aprimitive_mlessp__fR_A_mno_mfast_mbranches, hot)
50793   {
50794     /* This specialized instruction is a replacement. */
50795 #   undef JITTER_BRANCH_FAST
50796 #   define JITTER_BRANCH_FAST JITTER_BRANCH
50797 #   undef JITTER_BRANCH_FAST_IF_ZERO
50798 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
50799 #   undef JITTER_BRANCH_FAST_IF_NONZERO
50800 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
50801 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
50802 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
50803 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
50804 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
50805 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
50806 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
50807 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
50808 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
50809 #   undef JITTER_BRANCH_FAST_IF_EQUAL
50810 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
50811 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
50812 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
50813 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
50814 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
50815 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
50816 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
50817 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
50818 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
50819 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
50820 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
50821 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
50822 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
50823 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
50824 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
50825 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
50826 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
50827 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
50828 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
50829 #   undef JITTER_BRANCH_FAST_IF_AND
50830 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
50831 #   undef JITTER_BRANCH_FAST_IF_NOTAND
50832 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
50833 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
50834 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
50835 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
50836 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
50837 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
50838 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
50839 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
50840 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
50841 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
50842 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
50843 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
50844 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
50845 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
50846 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
50847 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
50848 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
50849 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
50850 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
50851 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
50852 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
50853 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
50854 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
50855 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
50856 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
50857 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
50858 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
50859     /* This specialized instruction is non-relocatable.
50860        Its 0-th argument, a literal, is the return address where to jump
50861        at the end, back to relocated code. */
50862 
50863 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       261
50864 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-lessp/fR*-no-fast-branches
50865 
50866 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mlessp__fR_A_mno_mfast_mbranches
50867 
50868   /* The residual arity for this instruction does not depend on fast labels. */
50869   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
50870 
50871   /* Define argument-access macros for *primitive-lessp/fR*-no-fast-branches . */
50872 #ifdef JITTER_HAVE_PATCH_IN
50873   /* Define argument-access macros assuming that fast branches are enabled. */
50874     /* The 0th argument is a residual label. */
50875 #if defined(JITTER_DISPATCH_NO_THREADING)
50876 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50877     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50878 #elif defined (JITTER_REPLICATE)
50879 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50880 #else
50881 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50882 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50883 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50884 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50885 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50886 #   define JITTER_ARGF0 JITTER_ARGP0
50887 
50888 #else
50889   /* Define argument-access macros assuming that fast branches are disabled. */
50890     /* The 0th argument is a residual label. */
50891 #if defined(JITTER_DISPATCH_NO_THREADING)
50892 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
50893     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
50894 #elif defined (JITTER_REPLICATE)
50895 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
50896 #else
50897 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
50898 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
50899 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
50900 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
50901 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
50902 #   define JITTER_ARGF0 JITTER_ARGP0
50903 
50904 # endif // #ifdef JITTER_HAVE_PATCH_IN
50905 
50906 #ifdef JITTER_REPLICATE
50907     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
50908        it on the stack rather than in read-only memory.  I had to do this to prevent
50909        a GCC 8 snapshot on SH from being too clever. */
50910     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50911     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
50912        in memory, as a 16-bit constant; and since it reads it with a PC-relative
50913        load the relocated part crashes.
50914                  mov.w     .L1667,r0
50915                  mov.l     @(r0,r15),r1
50916                  jmp       @r1
50917        r15 is the stack pointer.  The constant at .L1667 is
50918           .L1667:
50919                  .short    232
50920        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
50921        can't work as an immediate.  Shall I keep these code pointers as a single array?
50922        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
50923        but the problem will be the same. */
50924     /* Jump to non-relocatable code. */
50925     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
50926 
50927     /* Here the residual arity is given as zero: it's too late to
50928        skip residuals, since we've already jumped and this code is
50929        unreachable.  The instruction pointer, if any, is advanced
50930        in the non-relocatable code. */
50931     JITTER_INSTRUCTION_EPILOG_(*primitive-lessp/fR*-no-fast-branches, _Aprimitive_mlessp__fR_A_mno_mfast_mbranches, 0)
50932 
50933     /* Relocated code will jump to this label in non-relocated code. */
50934   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
50935     JITTER_COMMENT_IN_ASM_("*primitive-lessp/fR*-no-fast-branches non-relocatable code");
50936 #endif // #ifdef JITTER_REPLICATE
50937 #if defined (JITTER_PROFILE_SAMPLE)
50938   JITTER_PROFILE_SAMPLE_UPDATE
50939      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50940       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50941   /* Force the compiler not move sample-profiling instrumentation
50942      beyond this point; this way the actual user code is timed.
50943      This is still not perfect, as residuals are materialised before
50944      we arrive here, but should be adequate at least for slow VM
50945      instructions. */
50946   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
50947 #endif
50948 #if defined (JITTER_PROFILE_COUNT)
50949   /* Notice that, differently from the code above, this
50950      instrumentation code *can* be reordered freely: as long as a
50951      VM instruction is counted, the count increment can be placed
50952      anyehere.  Let GCC move this code and possibly achieve better
50953      throughput by exploiting instruction-level parallelism and
50954      therefore approximate more closely a non-profiled build. */
50955   JITTER_PROFILE_COUNT_UPDATE
50956      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
50957       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
50958 #endif
50959 
50960 /* User-specified code, instruction-beginning-c part: beginning. */
50961 
50962 
50963 /* User-specified code, instruction-beginning-c part: end */
50964 
50965 
50966     /* User code for *primitive-lessp/fR*-no-fast-branches . */
50967 
50968     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
50969     JITTERLISP_LESSP_(JITTER_TOP_MAINSTACK(),
50970                       JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
50971     JITTER_NIP_MAINSTACK();
50972 
50973     /* End of the user code for *primitive-lessp/fR*-no-fast-branches . */
50974 
50975 /* User-specified code, instruction-end-c part: beginning. */
50976 
50977 
50978 /* User-specified code, instruction-end-c part: end */
50979 
50980 #ifdef JITTER_REPLICATE
50981     /* Advance the instruction pointer, if any, to skip residuals;
50982        then jump back to replicated code. */
50983     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
50984     JITTER_SKIP_RESIDUALS_;
50985     goto * _jitter_back_to_replicated_code_pointer;
50986 #endif // #ifdef JITTER_REPLICATE
50987 
50988     /* Undefine the *primitive-lessp/fR*-no-fast-branches argument macros so they can't be used
50989        by mistake in the instruction body coming next. */
50990 #   undef JITTER_SLOW_REGISTER_OFFSET0
50991 #   undef JITTER_ARG0
50992 #   undef JITTER_ARGN0
50993 #   undef JITTER_ARGU0
50994 #   undef JITTER_ARGP0
50995 #   undef JITTER_ARGF0
50996 
50997 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
50998 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
50999 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
51000 
51001   }
51002 #ifndef JITTER_REPLICATE
51003  JITTER_INSTRUCTION_EPILOG_(*primitive-lessp/fR*-no-fast-branches, _Aprimitive_mlessp__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
51004 #endif // #ifndef JITTER_REPLICATE
51005 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
51006 
51007   JITTER_INSTRUCTION_PROLOG_(*primitive-negate/fR*-no-fast-branches, _Aprimitive_mnegate__fR_A_mno_mfast_mbranches, hot)
51008   {
51009     /* This specialized instruction is a replacement. */
51010 #   undef JITTER_BRANCH_FAST
51011 #   define JITTER_BRANCH_FAST JITTER_BRANCH
51012 #   undef JITTER_BRANCH_FAST_IF_ZERO
51013 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
51014 #   undef JITTER_BRANCH_FAST_IF_NONZERO
51015 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
51016 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
51017 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
51018 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
51019 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
51020 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
51021 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
51022 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
51023 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
51024 #   undef JITTER_BRANCH_FAST_IF_EQUAL
51025 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
51026 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
51027 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
51028 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
51029 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
51030 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
51031 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
51032 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
51033 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
51034 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
51035 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
51036 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
51037 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
51038 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
51039 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
51040 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
51041 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
51042 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
51043 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
51044 #   undef JITTER_BRANCH_FAST_IF_AND
51045 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
51046 #   undef JITTER_BRANCH_FAST_IF_NOTAND
51047 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
51048 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
51049 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
51050 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
51051 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
51052 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
51053 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
51054 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
51055 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
51056 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
51057 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
51058 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
51059 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
51060 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
51061 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
51062 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
51063 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
51064 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
51065 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
51066 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
51067 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
51068 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
51069 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
51070 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
51071 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
51072 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
51073 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
51074     /* This specialized instruction is non-relocatable.
51075        Its 0-th argument, a literal, is the return address where to jump
51076        at the end, back to relocated code. */
51077 
51078 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       262
51079 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-negate/fR*-no-fast-branches
51080 
51081 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mnegate__fR_A_mno_mfast_mbranches
51082 
51083   /* The residual arity for this instruction does not depend on fast labels. */
51084   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
51085 
51086   /* Define argument-access macros for *primitive-negate/fR*-no-fast-branches . */
51087 #ifdef JITTER_HAVE_PATCH_IN
51088   /* Define argument-access macros assuming that fast branches are enabled. */
51089     /* The 0th argument is a residual label. */
51090 #if defined(JITTER_DISPATCH_NO_THREADING)
51091 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51092     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51093 #elif defined (JITTER_REPLICATE)
51094 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51095 #else
51096 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51097 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51098 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51099 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51100 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51101 #   define JITTER_ARGF0 JITTER_ARGP0
51102 
51103 #else
51104   /* Define argument-access macros assuming that fast branches are disabled. */
51105     /* The 0th argument is a residual label. */
51106 #if defined(JITTER_DISPATCH_NO_THREADING)
51107 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51108     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51109 #elif defined (JITTER_REPLICATE)
51110 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51111 #else
51112 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51113 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51114 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51115 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51116 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51117 #   define JITTER_ARGF0 JITTER_ARGP0
51118 
51119 # endif // #ifdef JITTER_HAVE_PATCH_IN
51120 
51121 #ifdef JITTER_REPLICATE
51122     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
51123        it on the stack rather than in read-only memory.  I had to do this to prevent
51124        a GCC 8 snapshot on SH from being too clever. */
51125     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51126     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
51127        in memory, as a 16-bit constant; and since it reads it with a PC-relative
51128        load the relocated part crashes.
51129                  mov.w     .L1667,r0
51130                  mov.l     @(r0,r15),r1
51131                  jmp       @r1
51132        r15 is the stack pointer.  The constant at .L1667 is
51133           .L1667:
51134                  .short    232
51135        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
51136        can't work as an immediate.  Shall I keep these code pointers as a single array?
51137        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
51138        but the problem will be the same. */
51139     /* Jump to non-relocatable code. */
51140     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51141 
51142     /* Here the residual arity is given as zero: it's too late to
51143        skip residuals, since we've already jumped and this code is
51144        unreachable.  The instruction pointer, if any, is advanced
51145        in the non-relocatable code. */
51146     JITTER_INSTRUCTION_EPILOG_(*primitive-negate/fR*-no-fast-branches, _Aprimitive_mnegate__fR_A_mno_mfast_mbranches, 0)
51147 
51148     /* Relocated code will jump to this label in non-relocated code. */
51149   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
51150     JITTER_COMMENT_IN_ASM_("*primitive-negate/fR*-no-fast-branches non-relocatable code");
51151 #endif // #ifdef JITTER_REPLICATE
51152 #if defined (JITTER_PROFILE_SAMPLE)
51153   JITTER_PROFILE_SAMPLE_UPDATE
51154      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51155       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51156   /* Force the compiler not move sample-profiling instrumentation
51157      beyond this point; this way the actual user code is timed.
51158      This is still not perfect, as residuals are materialised before
51159      we arrive here, but should be adequate at least for slow VM
51160      instructions. */
51161   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
51162 #endif
51163 #if defined (JITTER_PROFILE_COUNT)
51164   /* Notice that, differently from the code above, this
51165      instrumentation code *can* be reordered freely: as long as a
51166      VM instruction is counted, the count increment can be placed
51167      anyehere.  Let GCC move this code and possibly achieve better
51168      throughput by exploiting instruction-level parallelism and
51169      therefore approximate more closely a non-profiled build. */
51170   JITTER_PROFILE_COUNT_UPDATE
51171      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51172       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51173 #endif
51174 
51175 /* User-specified code, instruction-beginning-c part: beginning. */
51176 
51177 
51178 /* User-specified code, instruction-beginning-c part: end */
51179 
51180 
51181     /* User code for *primitive-negate/fR*-no-fast-branches . */
51182 
51183     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
51184     JITTERLISP_NEGATE_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
51185                                    JITTER_TOP_MAINSTACK(),
51186                                    JITTER_ARGF0);
51187 
51188     /* End of the user code for *primitive-negate/fR*-no-fast-branches . */
51189 
51190 /* User-specified code, instruction-end-c part: beginning. */
51191 
51192 
51193 /* User-specified code, instruction-end-c part: end */
51194 
51195 #ifdef JITTER_REPLICATE
51196     /* Advance the instruction pointer, if any, to skip residuals;
51197        then jump back to replicated code. */
51198     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
51199     JITTER_SKIP_RESIDUALS_;
51200     goto * _jitter_back_to_replicated_code_pointer;
51201 #endif // #ifdef JITTER_REPLICATE
51202 
51203     /* Undefine the *primitive-negate/fR*-no-fast-branches argument macros so they can't be used
51204        by mistake in the instruction body coming next. */
51205 #   undef JITTER_SLOW_REGISTER_OFFSET0
51206 #   undef JITTER_ARG0
51207 #   undef JITTER_ARGN0
51208 #   undef JITTER_ARGU0
51209 #   undef JITTER_ARGP0
51210 #   undef JITTER_ARGF0
51211 
51212 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
51213 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
51214 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
51215 
51216   }
51217 #ifndef JITTER_REPLICATE
51218  JITTER_INSTRUCTION_EPILOG_(*primitive-negate/fR*-no-fast-branches, _Aprimitive_mnegate__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
51219 #endif // #ifndef JITTER_REPLICATE
51220 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
51221 
51222   JITTER_INSTRUCTION_PROLOG_(*primitive-negativep/fR*-no-fast-branches, _Aprimitive_mnegativep__fR_A_mno_mfast_mbranches, hot)
51223   {
51224     /* This specialized instruction is a replacement. */
51225 #   undef JITTER_BRANCH_FAST
51226 #   define JITTER_BRANCH_FAST JITTER_BRANCH
51227 #   undef JITTER_BRANCH_FAST_IF_ZERO
51228 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
51229 #   undef JITTER_BRANCH_FAST_IF_NONZERO
51230 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
51231 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
51232 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
51233 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
51234 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
51235 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
51236 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
51237 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
51238 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
51239 #   undef JITTER_BRANCH_FAST_IF_EQUAL
51240 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
51241 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
51242 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
51243 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
51244 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
51245 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
51246 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
51247 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
51248 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
51249 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
51250 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
51251 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
51252 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
51253 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
51254 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
51255 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
51256 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
51257 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
51258 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
51259 #   undef JITTER_BRANCH_FAST_IF_AND
51260 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
51261 #   undef JITTER_BRANCH_FAST_IF_NOTAND
51262 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
51263 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
51264 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
51265 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
51266 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
51267 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
51268 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
51269 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
51270 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
51271 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
51272 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
51273 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
51274 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
51275 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
51276 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
51277 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
51278 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
51279 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
51280 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
51281 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
51282 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
51283 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
51284 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
51285 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
51286 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
51287 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
51288 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
51289     /* This specialized instruction is non-relocatable.
51290        Its 0-th argument, a literal, is the return address where to jump
51291        at the end, back to relocated code. */
51292 
51293 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       263
51294 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-negativep/fR*-no-fast-branches
51295 
51296 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mnegativep__fR_A_mno_mfast_mbranches
51297 
51298   /* The residual arity for this instruction does not depend on fast labels. */
51299   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
51300 
51301   /* Define argument-access macros for *primitive-negativep/fR*-no-fast-branches . */
51302 #ifdef JITTER_HAVE_PATCH_IN
51303   /* Define argument-access macros assuming that fast branches are enabled. */
51304     /* The 0th argument is a residual label. */
51305 #if defined(JITTER_DISPATCH_NO_THREADING)
51306 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51307     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51308 #elif defined (JITTER_REPLICATE)
51309 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51310 #else
51311 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51312 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51313 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51314 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51315 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51316 #   define JITTER_ARGF0 JITTER_ARGP0
51317 
51318 #else
51319   /* Define argument-access macros assuming that fast branches are disabled. */
51320     /* The 0th argument is a residual label. */
51321 #if defined(JITTER_DISPATCH_NO_THREADING)
51322 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51323     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51324 #elif defined (JITTER_REPLICATE)
51325 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51326 #else
51327 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51328 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51329 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51330 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51331 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51332 #   define JITTER_ARGF0 JITTER_ARGP0
51333 
51334 # endif // #ifdef JITTER_HAVE_PATCH_IN
51335 
51336 #ifdef JITTER_REPLICATE
51337     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
51338        it on the stack rather than in read-only memory.  I had to do this to prevent
51339        a GCC 8 snapshot on SH from being too clever. */
51340     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51341     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
51342        in memory, as a 16-bit constant; and since it reads it with a PC-relative
51343        load the relocated part crashes.
51344                  mov.w     .L1667,r0
51345                  mov.l     @(r0,r15),r1
51346                  jmp       @r1
51347        r15 is the stack pointer.  The constant at .L1667 is
51348           .L1667:
51349                  .short    232
51350        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
51351        can't work as an immediate.  Shall I keep these code pointers as a single array?
51352        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
51353        but the problem will be the same. */
51354     /* Jump to non-relocatable code. */
51355     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51356 
51357     /* Here the residual arity is given as zero: it's too late to
51358        skip residuals, since we've already jumped and this code is
51359        unreachable.  The instruction pointer, if any, is advanced
51360        in the non-relocatable code. */
51361     JITTER_INSTRUCTION_EPILOG_(*primitive-negativep/fR*-no-fast-branches, _Aprimitive_mnegativep__fR_A_mno_mfast_mbranches, 0)
51362 
51363     /* Relocated code will jump to this label in non-relocated code. */
51364   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
51365     JITTER_COMMENT_IN_ASM_("*primitive-negativep/fR*-no-fast-branches non-relocatable code");
51366 #endif // #ifdef JITTER_REPLICATE
51367 #if defined (JITTER_PROFILE_SAMPLE)
51368   JITTER_PROFILE_SAMPLE_UPDATE
51369      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51370       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51371   /* Force the compiler not move sample-profiling instrumentation
51372      beyond this point; this way the actual user code is timed.
51373      This is still not perfect, as residuals are materialised before
51374      we arrive here, but should be adequate at least for slow VM
51375      instructions. */
51376   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
51377 #endif
51378 #if defined (JITTER_PROFILE_COUNT)
51379   /* Notice that, differently from the code above, this
51380      instrumentation code *can* be reordered freely: as long as a
51381      VM instruction is counted, the count increment can be placed
51382      anyehere.  Let GCC move this code and possibly achieve better
51383      throughput by exploiting instruction-level parallelism and
51384      therefore approximate more closely a non-profiled build. */
51385   JITTER_PROFILE_COUNT_UPDATE
51386      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51387       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51388 #endif
51389 
51390 /* User-specified code, instruction-beginning-c part: beginning. */
51391 
51392 
51393 /* User-specified code, instruction-beginning-c part: end */
51394 
51395 
51396     /* User code for *primitive-negativep/fR*-no-fast-branches . */
51397 
51398     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
51399     JITTERLISP_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
51400 
51401     /* End of the user code for *primitive-negativep/fR*-no-fast-branches . */
51402 
51403 /* User-specified code, instruction-end-c part: beginning. */
51404 
51405 
51406 /* User-specified code, instruction-end-c part: end */
51407 
51408 #ifdef JITTER_REPLICATE
51409     /* Advance the instruction pointer, if any, to skip residuals;
51410        then jump back to replicated code. */
51411     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
51412     JITTER_SKIP_RESIDUALS_;
51413     goto * _jitter_back_to_replicated_code_pointer;
51414 #endif // #ifdef JITTER_REPLICATE
51415 
51416     /* Undefine the *primitive-negativep/fR*-no-fast-branches argument macros so they can't be used
51417        by mistake in the instruction body coming next. */
51418 #   undef JITTER_SLOW_REGISTER_OFFSET0
51419 #   undef JITTER_ARG0
51420 #   undef JITTER_ARGN0
51421 #   undef JITTER_ARGU0
51422 #   undef JITTER_ARGP0
51423 #   undef JITTER_ARGF0
51424 
51425 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
51426 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
51427 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
51428 
51429   }
51430 #ifndef JITTER_REPLICATE
51431  JITTER_INSTRUCTION_EPILOG_(*primitive-negativep/fR*-no-fast-branches, _Aprimitive_mnegativep__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
51432 #endif // #ifndef JITTER_REPLICATE
51433 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
51434 
51435   JITTER_INSTRUCTION_PROLOG_(*primitive-non-negativep/fR*-no-fast-branches, _Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches, hot)
51436   {
51437     /* This specialized instruction is a replacement. */
51438 #   undef JITTER_BRANCH_FAST
51439 #   define JITTER_BRANCH_FAST JITTER_BRANCH
51440 #   undef JITTER_BRANCH_FAST_IF_ZERO
51441 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
51442 #   undef JITTER_BRANCH_FAST_IF_NONZERO
51443 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
51444 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
51445 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
51446 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
51447 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
51448 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
51449 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
51450 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
51451 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
51452 #   undef JITTER_BRANCH_FAST_IF_EQUAL
51453 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
51454 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
51455 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
51456 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
51457 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
51458 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
51459 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
51460 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
51461 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
51462 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
51463 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
51464 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
51465 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
51466 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
51467 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
51468 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
51469 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
51470 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
51471 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
51472 #   undef JITTER_BRANCH_FAST_IF_AND
51473 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
51474 #   undef JITTER_BRANCH_FAST_IF_NOTAND
51475 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
51476 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
51477 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
51478 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
51479 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
51480 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
51481 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
51482 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
51483 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
51484 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
51485 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
51486 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
51487 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
51488 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
51489 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
51490 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
51491 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
51492 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
51493 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
51494 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
51495 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
51496 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
51497 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
51498 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
51499 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
51500 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
51501 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
51502     /* This specialized instruction is non-relocatable.
51503        Its 0-th argument, a literal, is the return address where to jump
51504        at the end, back to relocated code. */
51505 
51506 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       264
51507 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-non-negativep/fR*-no-fast-branches
51508 
51509 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches
51510 
51511   /* The residual arity for this instruction does not depend on fast labels. */
51512   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
51513 
51514   /* Define argument-access macros for *primitive-non-negativep/fR*-no-fast-branches . */
51515 #ifdef JITTER_HAVE_PATCH_IN
51516   /* Define argument-access macros assuming that fast branches are enabled. */
51517     /* The 0th argument is a residual label. */
51518 #if defined(JITTER_DISPATCH_NO_THREADING)
51519 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51520     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51521 #elif defined (JITTER_REPLICATE)
51522 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51523 #else
51524 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51525 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51526 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51527 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51528 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51529 #   define JITTER_ARGF0 JITTER_ARGP0
51530 
51531 #else
51532   /* Define argument-access macros assuming that fast branches are disabled. */
51533     /* The 0th argument is a residual label. */
51534 #if defined(JITTER_DISPATCH_NO_THREADING)
51535 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51536     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51537 #elif defined (JITTER_REPLICATE)
51538 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51539 #else
51540 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51541 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51542 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51543 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51544 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51545 #   define JITTER_ARGF0 JITTER_ARGP0
51546 
51547 # endif // #ifdef JITTER_HAVE_PATCH_IN
51548 
51549 #ifdef JITTER_REPLICATE
51550     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
51551        it on the stack rather than in read-only memory.  I had to do this to prevent
51552        a GCC 8 snapshot on SH from being too clever. */
51553     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51554     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
51555        in memory, as a 16-bit constant; and since it reads it with a PC-relative
51556        load the relocated part crashes.
51557                  mov.w     .L1667,r0
51558                  mov.l     @(r0,r15),r1
51559                  jmp       @r1
51560        r15 is the stack pointer.  The constant at .L1667 is
51561           .L1667:
51562                  .short    232
51563        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
51564        can't work as an immediate.  Shall I keep these code pointers as a single array?
51565        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
51566        but the problem will be the same. */
51567     /* Jump to non-relocatable code. */
51568     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51569 
51570     /* Here the residual arity is given as zero: it's too late to
51571        skip residuals, since we've already jumped and this code is
51572        unreachable.  The instruction pointer, if any, is advanced
51573        in the non-relocatable code. */
51574     JITTER_INSTRUCTION_EPILOG_(*primitive-non-negativep/fR*-no-fast-branches, _Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches, 0)
51575 
51576     /* Relocated code will jump to this label in non-relocated code. */
51577   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
51578     JITTER_COMMENT_IN_ASM_("*primitive-non-negativep/fR*-no-fast-branches non-relocatable code");
51579 #endif // #ifdef JITTER_REPLICATE
51580 #if defined (JITTER_PROFILE_SAMPLE)
51581   JITTER_PROFILE_SAMPLE_UPDATE
51582      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51583       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51584   /* Force the compiler not move sample-profiling instrumentation
51585      beyond this point; this way the actual user code is timed.
51586      This is still not perfect, as residuals are materialised before
51587      we arrive here, but should be adequate at least for slow VM
51588      instructions. */
51589   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
51590 #endif
51591 #if defined (JITTER_PROFILE_COUNT)
51592   /* Notice that, differently from the code above, this
51593      instrumentation code *can* be reordered freely: as long as a
51594      VM instruction is counted, the count increment can be placed
51595      anyehere.  Let GCC move this code and possibly achieve better
51596      throughput by exploiting instruction-level parallelism and
51597      therefore approximate more closely a non-profiled build. */
51598   JITTER_PROFILE_COUNT_UPDATE
51599      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51600       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51601 #endif
51602 
51603 /* User-specified code, instruction-beginning-c part: beginning. */
51604 
51605 
51606 /* User-specified code, instruction-beginning-c part: end */
51607 
51608 
51609     /* User code for *primitive-non-negativep/fR*-no-fast-branches . */
51610 
51611     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
51612     JITTERLISP_NON_NEGATIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
51613 
51614     /* End of the user code for *primitive-non-negativep/fR*-no-fast-branches . */
51615 
51616 /* User-specified code, instruction-end-c part: beginning. */
51617 
51618 
51619 /* User-specified code, instruction-end-c part: end */
51620 
51621 #ifdef JITTER_REPLICATE
51622     /* Advance the instruction pointer, if any, to skip residuals;
51623        then jump back to replicated code. */
51624     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
51625     JITTER_SKIP_RESIDUALS_;
51626     goto * _jitter_back_to_replicated_code_pointer;
51627 #endif // #ifdef JITTER_REPLICATE
51628 
51629     /* Undefine the *primitive-non-negativep/fR*-no-fast-branches argument macros so they can't be used
51630        by mistake in the instruction body coming next. */
51631 #   undef JITTER_SLOW_REGISTER_OFFSET0
51632 #   undef JITTER_ARG0
51633 #   undef JITTER_ARGN0
51634 #   undef JITTER_ARGU0
51635 #   undef JITTER_ARGP0
51636 #   undef JITTER_ARGF0
51637 
51638 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
51639 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
51640 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
51641 
51642   }
51643 #ifndef JITTER_REPLICATE
51644  JITTER_INSTRUCTION_EPILOG_(*primitive-non-negativep/fR*-no-fast-branches, _Aprimitive_mnon_mnegativep__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
51645 #endif // #ifndef JITTER_REPLICATE
51646 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
51647 
51648   JITTER_INSTRUCTION_PROLOG_(*primitive-non-positivep/fR*-no-fast-branches, _Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches, hot)
51649   {
51650     /* This specialized instruction is a replacement. */
51651 #   undef JITTER_BRANCH_FAST
51652 #   define JITTER_BRANCH_FAST JITTER_BRANCH
51653 #   undef JITTER_BRANCH_FAST_IF_ZERO
51654 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
51655 #   undef JITTER_BRANCH_FAST_IF_NONZERO
51656 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
51657 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
51658 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
51659 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
51660 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
51661 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
51662 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
51663 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
51664 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
51665 #   undef JITTER_BRANCH_FAST_IF_EQUAL
51666 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
51667 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
51668 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
51669 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
51670 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
51671 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
51672 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
51673 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
51674 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
51675 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
51676 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
51677 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
51678 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
51679 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
51680 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
51681 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
51682 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
51683 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
51684 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
51685 #   undef JITTER_BRANCH_FAST_IF_AND
51686 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
51687 #   undef JITTER_BRANCH_FAST_IF_NOTAND
51688 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
51689 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
51690 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
51691 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
51692 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
51693 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
51694 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
51695 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
51696 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
51697 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
51698 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
51699 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
51700 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
51701 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
51702 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
51703 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
51704 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
51705 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
51706 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
51707 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
51708 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
51709 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
51710 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
51711 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
51712 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
51713 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
51714 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
51715     /* This specialized instruction is non-relocatable.
51716        Its 0-th argument, a literal, is the return address where to jump
51717        at the end, back to relocated code. */
51718 
51719 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       265
51720 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-non-positivep/fR*-no-fast-branches
51721 
51722 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches
51723 
51724   /* The residual arity for this instruction does not depend on fast labels. */
51725   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
51726 
51727   /* Define argument-access macros for *primitive-non-positivep/fR*-no-fast-branches . */
51728 #ifdef JITTER_HAVE_PATCH_IN
51729   /* Define argument-access macros assuming that fast branches are enabled. */
51730     /* The 0th argument is a residual label. */
51731 #if defined(JITTER_DISPATCH_NO_THREADING)
51732 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51733     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51734 #elif defined (JITTER_REPLICATE)
51735 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51736 #else
51737 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51738 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51739 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51740 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51741 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51742 #   define JITTER_ARGF0 JITTER_ARGP0
51743 
51744 #else
51745   /* Define argument-access macros assuming that fast branches are disabled. */
51746     /* The 0th argument is a residual label. */
51747 #if defined(JITTER_DISPATCH_NO_THREADING)
51748 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51749     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51750 #elif defined (JITTER_REPLICATE)
51751 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51752 #else
51753 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51754 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51755 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51756 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51757 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51758 #   define JITTER_ARGF0 JITTER_ARGP0
51759 
51760 # endif // #ifdef JITTER_HAVE_PATCH_IN
51761 
51762 #ifdef JITTER_REPLICATE
51763     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
51764        it on the stack rather than in read-only memory.  I had to do this to prevent
51765        a GCC 8 snapshot on SH from being too clever. */
51766     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51767     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
51768        in memory, as a 16-bit constant; and since it reads it with a PC-relative
51769        load the relocated part crashes.
51770                  mov.w     .L1667,r0
51771                  mov.l     @(r0,r15),r1
51772                  jmp       @r1
51773        r15 is the stack pointer.  The constant at .L1667 is
51774           .L1667:
51775                  .short    232
51776        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
51777        can't work as an immediate.  Shall I keep these code pointers as a single array?
51778        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
51779        but the problem will be the same. */
51780     /* Jump to non-relocatable code. */
51781     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51782 
51783     /* Here the residual arity is given as zero: it's too late to
51784        skip residuals, since we've already jumped and this code is
51785        unreachable.  The instruction pointer, if any, is advanced
51786        in the non-relocatable code. */
51787     JITTER_INSTRUCTION_EPILOG_(*primitive-non-positivep/fR*-no-fast-branches, _Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches, 0)
51788 
51789     /* Relocated code will jump to this label in non-relocated code. */
51790   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
51791     JITTER_COMMENT_IN_ASM_("*primitive-non-positivep/fR*-no-fast-branches non-relocatable code");
51792 #endif // #ifdef JITTER_REPLICATE
51793 #if defined (JITTER_PROFILE_SAMPLE)
51794   JITTER_PROFILE_SAMPLE_UPDATE
51795      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51796       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51797   /* Force the compiler not move sample-profiling instrumentation
51798      beyond this point; this way the actual user code is timed.
51799      This is still not perfect, as residuals are materialised before
51800      we arrive here, but should be adequate at least for slow VM
51801      instructions. */
51802   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
51803 #endif
51804 #if defined (JITTER_PROFILE_COUNT)
51805   /* Notice that, differently from the code above, this
51806      instrumentation code *can* be reordered freely: as long as a
51807      VM instruction is counted, the count increment can be placed
51808      anyehere.  Let GCC move this code and possibly achieve better
51809      throughput by exploiting instruction-level parallelism and
51810      therefore approximate more closely a non-profiled build. */
51811   JITTER_PROFILE_COUNT_UPDATE
51812      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
51813       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
51814 #endif
51815 
51816 /* User-specified code, instruction-beginning-c part: beginning. */
51817 
51818 
51819 /* User-specified code, instruction-beginning-c part: end */
51820 
51821 
51822     /* User code for *primitive-non-positivep/fR*-no-fast-branches . */
51823 
51824     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
51825     JITTERLISP_NON_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
51826 
51827     /* End of the user code for *primitive-non-positivep/fR*-no-fast-branches . */
51828 
51829 /* User-specified code, instruction-end-c part: beginning. */
51830 
51831 
51832 /* User-specified code, instruction-end-c part: end */
51833 
51834 #ifdef JITTER_REPLICATE
51835     /* Advance the instruction pointer, if any, to skip residuals;
51836        then jump back to replicated code. */
51837     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
51838     JITTER_SKIP_RESIDUALS_;
51839     goto * _jitter_back_to_replicated_code_pointer;
51840 #endif // #ifdef JITTER_REPLICATE
51841 
51842     /* Undefine the *primitive-non-positivep/fR*-no-fast-branches argument macros so they can't be used
51843        by mistake in the instruction body coming next. */
51844 #   undef JITTER_SLOW_REGISTER_OFFSET0
51845 #   undef JITTER_ARG0
51846 #   undef JITTER_ARGN0
51847 #   undef JITTER_ARGU0
51848 #   undef JITTER_ARGP0
51849 #   undef JITTER_ARGF0
51850 
51851 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
51852 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
51853 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
51854 
51855   }
51856 #ifndef JITTER_REPLICATE
51857  JITTER_INSTRUCTION_EPILOG_(*primitive-non-positivep/fR*-no-fast-branches, _Aprimitive_mnon_mpositivep__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
51858 #endif // #ifndef JITTER_REPLICATE
51859 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
51860 
51861   JITTER_INSTRUCTION_PROLOG_(*primitive-non-zerop/fR*-no-fast-branches, _Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches, hot)
51862   {
51863     /* This specialized instruction is a replacement. */
51864 #   undef JITTER_BRANCH_FAST
51865 #   define JITTER_BRANCH_FAST JITTER_BRANCH
51866 #   undef JITTER_BRANCH_FAST_IF_ZERO
51867 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
51868 #   undef JITTER_BRANCH_FAST_IF_NONZERO
51869 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
51870 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
51871 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
51872 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
51873 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
51874 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
51875 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
51876 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
51877 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
51878 #   undef JITTER_BRANCH_FAST_IF_EQUAL
51879 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
51880 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
51881 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
51882 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
51883 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
51884 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
51885 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
51886 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
51887 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
51888 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
51889 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
51890 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
51891 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
51892 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
51893 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
51894 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
51895 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
51896 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
51897 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
51898 #   undef JITTER_BRANCH_FAST_IF_AND
51899 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
51900 #   undef JITTER_BRANCH_FAST_IF_NOTAND
51901 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
51902 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
51903 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
51904 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
51905 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
51906 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
51907 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
51908 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
51909 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
51910 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
51911 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
51912 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
51913 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
51914 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
51915 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
51916 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
51917 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
51918 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
51919 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
51920 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
51921 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
51922 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
51923 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
51924 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
51925 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
51926 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
51927 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
51928     /* This specialized instruction is non-relocatable.
51929        Its 0-th argument, a literal, is the return address where to jump
51930        at the end, back to relocated code. */
51931 
51932 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       266
51933 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-non-zerop/fR*-no-fast-branches
51934 
51935 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches
51936 
51937   /* The residual arity for this instruction does not depend on fast labels. */
51938   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
51939 
51940   /* Define argument-access macros for *primitive-non-zerop/fR*-no-fast-branches . */
51941 #ifdef JITTER_HAVE_PATCH_IN
51942   /* Define argument-access macros assuming that fast branches are enabled. */
51943     /* The 0th argument is a residual label. */
51944 #if defined(JITTER_DISPATCH_NO_THREADING)
51945 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51946     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51947 #elif defined (JITTER_REPLICATE)
51948 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51949 #else
51950 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51951 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51952 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51953 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51954 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51955 #   define JITTER_ARGF0 JITTER_ARGP0
51956 
51957 #else
51958   /* Define argument-access macros assuming that fast branches are disabled. */
51959     /* The 0th argument is a residual label. */
51960 #if defined(JITTER_DISPATCH_NO_THREADING)
51961 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
51962     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
51963 #elif defined (JITTER_REPLICATE)
51964 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
51965 #else
51966 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
51967 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
51968 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
51969 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
51970 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
51971 #   define JITTER_ARGF0 JITTER_ARGP0
51972 
51973 # endif // #ifdef JITTER_HAVE_PATCH_IN
51974 
51975 #ifdef JITTER_REPLICATE
51976     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
51977        it on the stack rather than in read-only memory.  I had to do this to prevent
51978        a GCC 8 snapshot on SH from being too clever. */
51979     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51980     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
51981        in memory, as a 16-bit constant; and since it reads it with a PC-relative
51982        load the relocated part crashes.
51983                  mov.w     .L1667,r0
51984                  mov.l     @(r0,r15),r1
51985                  jmp       @r1
51986        r15 is the stack pointer.  The constant at .L1667 is
51987           .L1667:
51988                  .short    232
51989        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
51990        can't work as an immediate.  Shall I keep these code pointers as a single array?
51991        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
51992        but the problem will be the same. */
51993     /* Jump to non-relocatable code. */
51994     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
51995 
51996     /* Here the residual arity is given as zero: it's too late to
51997        skip residuals, since we've already jumped and this code is
51998        unreachable.  The instruction pointer, if any, is advanced
51999        in the non-relocatable code. */
52000     JITTER_INSTRUCTION_EPILOG_(*primitive-non-zerop/fR*-no-fast-branches, _Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches, 0)
52001 
52002     /* Relocated code will jump to this label in non-relocated code. */
52003   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
52004     JITTER_COMMENT_IN_ASM_("*primitive-non-zerop/fR*-no-fast-branches non-relocatable code");
52005 #endif // #ifdef JITTER_REPLICATE
52006 #if defined (JITTER_PROFILE_SAMPLE)
52007   JITTER_PROFILE_SAMPLE_UPDATE
52008      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52009       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52010   /* Force the compiler not move sample-profiling instrumentation
52011      beyond this point; this way the actual user code is timed.
52012      This is still not perfect, as residuals are materialised before
52013      we arrive here, but should be adequate at least for slow VM
52014      instructions. */
52015   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
52016 #endif
52017 #if defined (JITTER_PROFILE_COUNT)
52018   /* Notice that, differently from the code above, this
52019      instrumentation code *can* be reordered freely: as long as a
52020      VM instruction is counted, the count increment can be placed
52021      anyehere.  Let GCC move this code and possibly achieve better
52022      throughput by exploiting instruction-level parallelism and
52023      therefore approximate more closely a non-profiled build. */
52024   JITTER_PROFILE_COUNT_UPDATE
52025      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52026       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52027 #endif
52028 
52029 /* User-specified code, instruction-beginning-c part: beginning. */
52030 
52031 
52032 /* User-specified code, instruction-beginning-c part: end */
52033 
52034 
52035     /* User code for *primitive-non-zerop/fR*-no-fast-branches . */
52036 
52037     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
52038     JITTERLISP_NON_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
52039 
52040     /* End of the user code for *primitive-non-zerop/fR*-no-fast-branches . */
52041 
52042 /* User-specified code, instruction-end-c part: beginning. */
52043 
52044 
52045 /* User-specified code, instruction-end-c part: end */
52046 
52047 #ifdef JITTER_REPLICATE
52048     /* Advance the instruction pointer, if any, to skip residuals;
52049        then jump back to replicated code. */
52050     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
52051     JITTER_SKIP_RESIDUALS_;
52052     goto * _jitter_back_to_replicated_code_pointer;
52053 #endif // #ifdef JITTER_REPLICATE
52054 
52055     /* Undefine the *primitive-non-zerop/fR*-no-fast-branches argument macros so they can't be used
52056        by mistake in the instruction body coming next. */
52057 #   undef JITTER_SLOW_REGISTER_OFFSET0
52058 #   undef JITTER_ARG0
52059 #   undef JITTER_ARGN0
52060 #   undef JITTER_ARGU0
52061 #   undef JITTER_ARGP0
52062 #   undef JITTER_ARGF0
52063 
52064 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
52065 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
52066 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
52067 
52068   }
52069 #ifndef JITTER_REPLICATE
52070  JITTER_INSTRUCTION_EPILOG_(*primitive-non-zerop/fR*-no-fast-branches, _Aprimitive_mnon_mzerop__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
52071 #endif // #ifndef JITTER_REPLICATE
52072 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
52073 
52074   JITTER_INSTRUCTION_PROLOG_(*primitive-not-greaterp/fR*-no-fast-branches, _Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches, hot)
52075   {
52076     /* This specialized instruction is a replacement. */
52077 #   undef JITTER_BRANCH_FAST
52078 #   define JITTER_BRANCH_FAST JITTER_BRANCH
52079 #   undef JITTER_BRANCH_FAST_IF_ZERO
52080 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
52081 #   undef JITTER_BRANCH_FAST_IF_NONZERO
52082 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
52083 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
52084 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
52085 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
52086 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
52087 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
52088 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
52089 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
52090 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
52091 #   undef JITTER_BRANCH_FAST_IF_EQUAL
52092 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
52093 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
52094 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
52095 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
52096 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
52097 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
52098 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
52099 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
52100 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
52101 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
52102 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
52103 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
52104 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
52105 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
52106 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
52107 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
52108 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
52109 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
52110 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
52111 #   undef JITTER_BRANCH_FAST_IF_AND
52112 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
52113 #   undef JITTER_BRANCH_FAST_IF_NOTAND
52114 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
52115 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
52116 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
52117 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
52118 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
52119 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
52120 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
52121 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
52122 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
52123 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
52124 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
52125 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
52126 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
52127 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
52128 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
52129 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
52130 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
52131 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
52132 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
52133 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
52134 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
52135 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
52136 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
52137 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
52138 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
52139 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
52140 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
52141     /* This specialized instruction is non-relocatable.
52142        Its 0-th argument, a literal, is the return address where to jump
52143        at the end, back to relocated code. */
52144 
52145 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       267
52146 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-not-greaterp/fR*-no-fast-branches
52147 
52148 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches
52149 
52150   /* The residual arity for this instruction does not depend on fast labels. */
52151   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
52152 
52153   /* Define argument-access macros for *primitive-not-greaterp/fR*-no-fast-branches . */
52154 #ifdef JITTER_HAVE_PATCH_IN
52155   /* Define argument-access macros assuming that fast branches are enabled. */
52156     /* The 0th argument is a residual label. */
52157 #if defined(JITTER_DISPATCH_NO_THREADING)
52158 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52159     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52160 #elif defined (JITTER_REPLICATE)
52161 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52162 #else
52163 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52164 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52165 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52166 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52167 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52168 #   define JITTER_ARGF0 JITTER_ARGP0
52169 
52170 #else
52171   /* Define argument-access macros assuming that fast branches are disabled. */
52172     /* The 0th argument is a residual label. */
52173 #if defined(JITTER_DISPATCH_NO_THREADING)
52174 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52175     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52176 #elif defined (JITTER_REPLICATE)
52177 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52178 #else
52179 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52180 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52181 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52182 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52183 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52184 #   define JITTER_ARGF0 JITTER_ARGP0
52185 
52186 # endif // #ifdef JITTER_HAVE_PATCH_IN
52187 
52188 #ifdef JITTER_REPLICATE
52189     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
52190        it on the stack rather than in read-only memory.  I had to do this to prevent
52191        a GCC 8 snapshot on SH from being too clever. */
52192     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52193     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
52194        in memory, as a 16-bit constant; and since it reads it with a PC-relative
52195        load the relocated part crashes.
52196                  mov.w     .L1667,r0
52197                  mov.l     @(r0,r15),r1
52198                  jmp       @r1
52199        r15 is the stack pointer.  The constant at .L1667 is
52200           .L1667:
52201                  .short    232
52202        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
52203        can't work as an immediate.  Shall I keep these code pointers as a single array?
52204        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
52205        but the problem will be the same. */
52206     /* Jump to non-relocatable code. */
52207     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52208 
52209     /* Here the residual arity is given as zero: it's too late to
52210        skip residuals, since we've already jumped and this code is
52211        unreachable.  The instruction pointer, if any, is advanced
52212        in the non-relocatable code. */
52213     JITTER_INSTRUCTION_EPILOG_(*primitive-not-greaterp/fR*-no-fast-branches, _Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches, 0)
52214 
52215     /* Relocated code will jump to this label in non-relocated code. */
52216   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
52217     JITTER_COMMENT_IN_ASM_("*primitive-not-greaterp/fR*-no-fast-branches non-relocatable code");
52218 #endif // #ifdef JITTER_REPLICATE
52219 #if defined (JITTER_PROFILE_SAMPLE)
52220   JITTER_PROFILE_SAMPLE_UPDATE
52221      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52222       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52223   /* Force the compiler not move sample-profiling instrumentation
52224      beyond this point; this way the actual user code is timed.
52225      This is still not perfect, as residuals are materialised before
52226      we arrive here, but should be adequate at least for slow VM
52227      instructions. */
52228   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
52229 #endif
52230 #if defined (JITTER_PROFILE_COUNT)
52231   /* Notice that, differently from the code above, this
52232      instrumentation code *can* be reordered freely: as long as a
52233      VM instruction is counted, the count increment can be placed
52234      anyehere.  Let GCC move this code and possibly achieve better
52235      throughput by exploiting instruction-level parallelism and
52236      therefore approximate more closely a non-profiled build. */
52237   JITTER_PROFILE_COUNT_UPDATE
52238      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52239       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52240 #endif
52241 
52242 /* User-specified code, instruction-beginning-c part: beginning. */
52243 
52244 
52245 /* User-specified code, instruction-beginning-c part: end */
52246 
52247 
52248     /* User code for *primitive-not-greaterp/fR*-no-fast-branches . */
52249 
52250     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
52251     JITTERLISP_NOTGREATERP_(JITTER_TOP_MAINSTACK(),
52252                             JITTER_UNDER_TOP_MAINSTACK(),
52253                             JITTER_TOP_MAINSTACK());
52254     JITTER_NIP_MAINSTACK();
52255 
52256     /* End of the user code for *primitive-not-greaterp/fR*-no-fast-branches . */
52257 
52258 /* User-specified code, instruction-end-c part: beginning. */
52259 
52260 
52261 /* User-specified code, instruction-end-c part: end */
52262 
52263 #ifdef JITTER_REPLICATE
52264     /* Advance the instruction pointer, if any, to skip residuals;
52265        then jump back to replicated code. */
52266     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
52267     JITTER_SKIP_RESIDUALS_;
52268     goto * _jitter_back_to_replicated_code_pointer;
52269 #endif // #ifdef JITTER_REPLICATE
52270 
52271     /* Undefine the *primitive-not-greaterp/fR*-no-fast-branches argument macros so they can't be used
52272        by mistake in the instruction body coming next. */
52273 #   undef JITTER_SLOW_REGISTER_OFFSET0
52274 #   undef JITTER_ARG0
52275 #   undef JITTER_ARGN0
52276 #   undef JITTER_ARGU0
52277 #   undef JITTER_ARGP0
52278 #   undef JITTER_ARGF0
52279 
52280 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
52281 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
52282 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
52283 
52284   }
52285 #ifndef JITTER_REPLICATE
52286  JITTER_INSTRUCTION_EPILOG_(*primitive-not-greaterp/fR*-no-fast-branches, _Aprimitive_mnot_mgreaterp__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
52287 #endif // #ifndef JITTER_REPLICATE
52288 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
52289 
52290   JITTER_INSTRUCTION_PROLOG_(*primitive-not-lessp/fR*-no-fast-branches, _Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches, hot)
52291   {
52292     /* This specialized instruction is a replacement. */
52293 #   undef JITTER_BRANCH_FAST
52294 #   define JITTER_BRANCH_FAST JITTER_BRANCH
52295 #   undef JITTER_BRANCH_FAST_IF_ZERO
52296 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
52297 #   undef JITTER_BRANCH_FAST_IF_NONZERO
52298 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
52299 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
52300 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
52301 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
52302 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
52303 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
52304 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
52305 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
52306 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
52307 #   undef JITTER_BRANCH_FAST_IF_EQUAL
52308 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
52309 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
52310 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
52311 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
52312 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
52313 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
52314 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
52315 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
52316 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
52317 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
52318 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
52319 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
52320 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
52321 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
52322 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
52323 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
52324 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
52325 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
52326 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
52327 #   undef JITTER_BRANCH_FAST_IF_AND
52328 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
52329 #   undef JITTER_BRANCH_FAST_IF_NOTAND
52330 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
52331 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
52332 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
52333 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
52334 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
52335 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
52336 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
52337 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
52338 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
52339 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
52340 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
52341 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
52342 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
52343 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
52344 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
52345 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
52346 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
52347 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
52348 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
52349 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
52350 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
52351 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
52352 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
52353 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
52354 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
52355 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
52356 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
52357     /* This specialized instruction is non-relocatable.
52358        Its 0-th argument, a literal, is the return address where to jump
52359        at the end, back to relocated code. */
52360 
52361 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       268
52362 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-not-lessp/fR*-no-fast-branches
52363 
52364 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches
52365 
52366   /* The residual arity for this instruction does not depend on fast labels. */
52367   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
52368 
52369   /* Define argument-access macros for *primitive-not-lessp/fR*-no-fast-branches . */
52370 #ifdef JITTER_HAVE_PATCH_IN
52371   /* Define argument-access macros assuming that fast branches are enabled. */
52372     /* The 0th argument is a residual label. */
52373 #if defined(JITTER_DISPATCH_NO_THREADING)
52374 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52375     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52376 #elif defined (JITTER_REPLICATE)
52377 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52378 #else
52379 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52380 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52381 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52382 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52383 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52384 #   define JITTER_ARGF0 JITTER_ARGP0
52385 
52386 #else
52387   /* Define argument-access macros assuming that fast branches are disabled. */
52388     /* The 0th argument is a residual label. */
52389 #if defined(JITTER_DISPATCH_NO_THREADING)
52390 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52391     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52392 #elif defined (JITTER_REPLICATE)
52393 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52394 #else
52395 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52396 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52397 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52398 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52399 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52400 #   define JITTER_ARGF0 JITTER_ARGP0
52401 
52402 # endif // #ifdef JITTER_HAVE_PATCH_IN
52403 
52404 #ifdef JITTER_REPLICATE
52405     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
52406        it on the stack rather than in read-only memory.  I had to do this to prevent
52407        a GCC 8 snapshot on SH from being too clever. */
52408     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52409     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
52410        in memory, as a 16-bit constant; and since it reads it with a PC-relative
52411        load the relocated part crashes.
52412                  mov.w     .L1667,r0
52413                  mov.l     @(r0,r15),r1
52414                  jmp       @r1
52415        r15 is the stack pointer.  The constant at .L1667 is
52416           .L1667:
52417                  .short    232
52418        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
52419        can't work as an immediate.  Shall I keep these code pointers as a single array?
52420        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
52421        but the problem will be the same. */
52422     /* Jump to non-relocatable code. */
52423     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52424 
52425     /* Here the residual arity is given as zero: it's too late to
52426        skip residuals, since we've already jumped and this code is
52427        unreachable.  The instruction pointer, if any, is advanced
52428        in the non-relocatable code. */
52429     JITTER_INSTRUCTION_EPILOG_(*primitive-not-lessp/fR*-no-fast-branches, _Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches, 0)
52430 
52431     /* Relocated code will jump to this label in non-relocated code. */
52432   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
52433     JITTER_COMMENT_IN_ASM_("*primitive-not-lessp/fR*-no-fast-branches non-relocatable code");
52434 #endif // #ifdef JITTER_REPLICATE
52435 #if defined (JITTER_PROFILE_SAMPLE)
52436   JITTER_PROFILE_SAMPLE_UPDATE
52437      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52438       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52439   /* Force the compiler not move sample-profiling instrumentation
52440      beyond this point; this way the actual user code is timed.
52441      This is still not perfect, as residuals are materialised before
52442      we arrive here, but should be adequate at least for slow VM
52443      instructions. */
52444   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
52445 #endif
52446 #if defined (JITTER_PROFILE_COUNT)
52447   /* Notice that, differently from the code above, this
52448      instrumentation code *can* be reordered freely: as long as a
52449      VM instruction is counted, the count increment can be placed
52450      anyehere.  Let GCC move this code and possibly achieve better
52451      throughput by exploiting instruction-level parallelism and
52452      therefore approximate more closely a non-profiled build. */
52453   JITTER_PROFILE_COUNT_UPDATE
52454      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52455       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52456 #endif
52457 
52458 /* User-specified code, instruction-beginning-c part: beginning. */
52459 
52460 
52461 /* User-specified code, instruction-beginning-c part: end */
52462 
52463 
52464     /* User code for *primitive-not-lessp/fR*-no-fast-branches . */
52465 
52466     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
52467     JITTERLISP_NOTLESSP_(JITTER_TOP_MAINSTACK(),
52468                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
52469     JITTER_NIP_MAINSTACK();
52470 
52471     /* End of the user code for *primitive-not-lessp/fR*-no-fast-branches . */
52472 
52473 /* User-specified code, instruction-end-c part: beginning. */
52474 
52475 
52476 /* User-specified code, instruction-end-c part: end */
52477 
52478 #ifdef JITTER_REPLICATE
52479     /* Advance the instruction pointer, if any, to skip residuals;
52480        then jump back to replicated code. */
52481     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
52482     JITTER_SKIP_RESIDUALS_;
52483     goto * _jitter_back_to_replicated_code_pointer;
52484 #endif // #ifdef JITTER_REPLICATE
52485 
52486     /* Undefine the *primitive-not-lessp/fR*-no-fast-branches argument macros so they can't be used
52487        by mistake in the instruction body coming next. */
52488 #   undef JITTER_SLOW_REGISTER_OFFSET0
52489 #   undef JITTER_ARG0
52490 #   undef JITTER_ARGN0
52491 #   undef JITTER_ARGU0
52492 #   undef JITTER_ARGP0
52493 #   undef JITTER_ARGF0
52494 
52495 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
52496 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
52497 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
52498 
52499   }
52500 #ifndef JITTER_REPLICATE
52501  JITTER_INSTRUCTION_EPILOG_(*primitive-not-lessp/fR*-no-fast-branches, _Aprimitive_mnot_mlessp__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
52502 #endif // #ifndef JITTER_REPLICATE
52503 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
52504 
52505   JITTER_INSTRUCTION_PROLOG_(*primitive-one-minus/fR*-no-fast-branches, _Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches, hot)
52506   {
52507     /* This specialized instruction is a replacement. */
52508 #   undef JITTER_BRANCH_FAST
52509 #   define JITTER_BRANCH_FAST JITTER_BRANCH
52510 #   undef JITTER_BRANCH_FAST_IF_ZERO
52511 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
52512 #   undef JITTER_BRANCH_FAST_IF_NONZERO
52513 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
52514 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
52515 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
52516 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
52517 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
52518 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
52519 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
52520 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
52521 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
52522 #   undef JITTER_BRANCH_FAST_IF_EQUAL
52523 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
52524 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
52525 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
52526 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
52527 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
52528 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
52529 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
52530 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
52531 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
52532 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
52533 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
52534 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
52535 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
52536 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
52537 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
52538 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
52539 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
52540 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
52541 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
52542 #   undef JITTER_BRANCH_FAST_IF_AND
52543 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
52544 #   undef JITTER_BRANCH_FAST_IF_NOTAND
52545 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
52546 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
52547 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
52548 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
52549 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
52550 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
52551 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
52552 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
52553 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
52554 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
52555 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
52556 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
52557 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
52558 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
52559 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
52560 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
52561 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
52562 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
52563 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
52564 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
52565 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
52566 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
52567 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
52568 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
52569 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
52570 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
52571 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
52572     /* This specialized instruction is non-relocatable.
52573        Its 0-th argument, a literal, is the return address where to jump
52574        at the end, back to relocated code. */
52575 
52576 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       269
52577 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-one-minus/fR*-no-fast-branches
52578 
52579 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches
52580 
52581   /* The residual arity for this instruction does not depend on fast labels. */
52582   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
52583 
52584   /* Define argument-access macros for *primitive-one-minus/fR*-no-fast-branches . */
52585 #ifdef JITTER_HAVE_PATCH_IN
52586   /* Define argument-access macros assuming that fast branches are enabled. */
52587     /* The 0th argument is a residual label. */
52588 #if defined(JITTER_DISPATCH_NO_THREADING)
52589 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52590     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52591 #elif defined (JITTER_REPLICATE)
52592 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52593 #else
52594 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52595 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52596 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52597 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52598 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52599 #   define JITTER_ARGF0 JITTER_ARGP0
52600 
52601 #else
52602   /* Define argument-access macros assuming that fast branches are disabled. */
52603     /* The 0th argument is a residual label. */
52604 #if defined(JITTER_DISPATCH_NO_THREADING)
52605 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52606     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52607 #elif defined (JITTER_REPLICATE)
52608 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52609 #else
52610 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52611 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52612 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52613 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52614 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52615 #   define JITTER_ARGF0 JITTER_ARGP0
52616 
52617 # endif // #ifdef JITTER_HAVE_PATCH_IN
52618 
52619 #ifdef JITTER_REPLICATE
52620     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
52621        it on the stack rather than in read-only memory.  I had to do this to prevent
52622        a GCC 8 snapshot on SH from being too clever. */
52623     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52624     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
52625        in memory, as a 16-bit constant; and since it reads it with a PC-relative
52626        load the relocated part crashes.
52627                  mov.w     .L1667,r0
52628                  mov.l     @(r0,r15),r1
52629                  jmp       @r1
52630        r15 is the stack pointer.  The constant at .L1667 is
52631           .L1667:
52632                  .short    232
52633        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
52634        can't work as an immediate.  Shall I keep these code pointers as a single array?
52635        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
52636        but the problem will be the same. */
52637     /* Jump to non-relocatable code. */
52638     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52639 
52640     /* Here the residual arity is given as zero: it's too late to
52641        skip residuals, since we've already jumped and this code is
52642        unreachable.  The instruction pointer, if any, is advanced
52643        in the non-relocatable code. */
52644     JITTER_INSTRUCTION_EPILOG_(*primitive-one-minus/fR*-no-fast-branches, _Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches, 0)
52645 
52646     /* Relocated code will jump to this label in non-relocated code. */
52647   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
52648     JITTER_COMMENT_IN_ASM_("*primitive-one-minus/fR*-no-fast-branches non-relocatable code");
52649 #endif // #ifdef JITTER_REPLICATE
52650 #if defined (JITTER_PROFILE_SAMPLE)
52651   JITTER_PROFILE_SAMPLE_UPDATE
52652      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52653       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52654   /* Force the compiler not move sample-profiling instrumentation
52655      beyond this point; this way the actual user code is timed.
52656      This is still not perfect, as residuals are materialised before
52657      we arrive here, but should be adequate at least for slow VM
52658      instructions. */
52659   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
52660 #endif
52661 #if defined (JITTER_PROFILE_COUNT)
52662   /* Notice that, differently from the code above, this
52663      instrumentation code *can* be reordered freely: as long as a
52664      VM instruction is counted, the count increment can be placed
52665      anyehere.  Let GCC move this code and possibly achieve better
52666      throughput by exploiting instruction-level parallelism and
52667      therefore approximate more closely a non-profiled build. */
52668   JITTER_PROFILE_COUNT_UPDATE
52669      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52670       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52671 #endif
52672 
52673 /* User-specified code, instruction-beginning-c part: beginning. */
52674 
52675 
52676 /* User-specified code, instruction-beginning-c part: end */
52677 
52678 
52679     /* User code for *primitive-one-minus/fR*-no-fast-branches . */
52680 
52681     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
52682     JITTERLISP_1MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
52683                                    JITTER_TOP_MAINSTACK(),
52684                                    JITTER_ARGF0);
52685 
52686     /* End of the user code for *primitive-one-minus/fR*-no-fast-branches . */
52687 
52688 /* User-specified code, instruction-end-c part: beginning. */
52689 
52690 
52691 /* User-specified code, instruction-end-c part: end */
52692 
52693 #ifdef JITTER_REPLICATE
52694     /* Advance the instruction pointer, if any, to skip residuals;
52695        then jump back to replicated code. */
52696     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
52697     JITTER_SKIP_RESIDUALS_;
52698     goto * _jitter_back_to_replicated_code_pointer;
52699 #endif // #ifdef JITTER_REPLICATE
52700 
52701     /* Undefine the *primitive-one-minus/fR*-no-fast-branches argument macros so they can't be used
52702        by mistake in the instruction body coming next. */
52703 #   undef JITTER_SLOW_REGISTER_OFFSET0
52704 #   undef JITTER_ARG0
52705 #   undef JITTER_ARGN0
52706 #   undef JITTER_ARGU0
52707 #   undef JITTER_ARGP0
52708 #   undef JITTER_ARGF0
52709 
52710 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
52711 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
52712 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
52713 
52714   }
52715 #ifndef JITTER_REPLICATE
52716  JITTER_INSTRUCTION_EPILOG_(*primitive-one-minus/fR*-no-fast-branches, _Aprimitive_mone_mminus__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
52717 #endif // #ifndef JITTER_REPLICATE
52718 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
52719 
52720   JITTER_INSTRUCTION_PROLOG_(*primitive-one-plus/fR*-no-fast-branches, _Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches, hot)
52721   {
52722     /* This specialized instruction is a replacement. */
52723 #   undef JITTER_BRANCH_FAST
52724 #   define JITTER_BRANCH_FAST JITTER_BRANCH
52725 #   undef JITTER_BRANCH_FAST_IF_ZERO
52726 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
52727 #   undef JITTER_BRANCH_FAST_IF_NONZERO
52728 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
52729 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
52730 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
52731 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
52732 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
52733 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
52734 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
52735 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
52736 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
52737 #   undef JITTER_BRANCH_FAST_IF_EQUAL
52738 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
52739 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
52740 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
52741 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
52742 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
52743 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
52744 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
52745 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
52746 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
52747 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
52748 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
52749 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
52750 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
52751 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
52752 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
52753 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
52754 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
52755 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
52756 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
52757 #   undef JITTER_BRANCH_FAST_IF_AND
52758 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
52759 #   undef JITTER_BRANCH_FAST_IF_NOTAND
52760 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
52761 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
52762 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
52763 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
52764 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
52765 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
52766 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
52767 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
52768 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
52769 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
52770 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
52771 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
52772 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
52773 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
52774 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
52775 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
52776 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
52777 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
52778 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
52779 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
52780 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
52781 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
52782 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
52783 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
52784 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
52785 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
52786 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
52787     /* This specialized instruction is non-relocatable.
52788        Its 0-th argument, a literal, is the return address where to jump
52789        at the end, back to relocated code. */
52790 
52791 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       270
52792 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-one-plus/fR*-no-fast-branches
52793 
52794 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches
52795 
52796   /* The residual arity for this instruction does not depend on fast labels. */
52797   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
52798 
52799   /* Define argument-access macros for *primitive-one-plus/fR*-no-fast-branches . */
52800 #ifdef JITTER_HAVE_PATCH_IN
52801   /* Define argument-access macros assuming that fast branches are enabled. */
52802     /* The 0th argument is a residual label. */
52803 #if defined(JITTER_DISPATCH_NO_THREADING)
52804 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52805     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52806 #elif defined (JITTER_REPLICATE)
52807 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52808 #else
52809 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52810 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52811 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52812 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52813 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52814 #   define JITTER_ARGF0 JITTER_ARGP0
52815 
52816 #else
52817   /* Define argument-access macros assuming that fast branches are disabled. */
52818     /* The 0th argument is a residual label. */
52819 #if defined(JITTER_DISPATCH_NO_THREADING)
52820 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
52821     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
52822 #elif defined (JITTER_REPLICATE)
52823 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
52824 #else
52825 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
52826 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
52827 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
52828 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
52829 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
52830 #   define JITTER_ARGF0 JITTER_ARGP0
52831 
52832 # endif // #ifdef JITTER_HAVE_PATCH_IN
52833 
52834 #ifdef JITTER_REPLICATE
52835     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
52836        it on the stack rather than in read-only memory.  I had to do this to prevent
52837        a GCC 8 snapshot on SH from being too clever. */
52838     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52839     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
52840        in memory, as a 16-bit constant; and since it reads it with a PC-relative
52841        load the relocated part crashes.
52842                  mov.w     .L1667,r0
52843                  mov.l     @(r0,r15),r1
52844                  jmp       @r1
52845        r15 is the stack pointer.  The constant at .L1667 is
52846           .L1667:
52847                  .short    232
52848        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
52849        can't work as an immediate.  Shall I keep these code pointers as a single array?
52850        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
52851        but the problem will be the same. */
52852     /* Jump to non-relocatable code. */
52853     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
52854 
52855     /* Here the residual arity is given as zero: it's too late to
52856        skip residuals, since we've already jumped and this code is
52857        unreachable.  The instruction pointer, if any, is advanced
52858        in the non-relocatable code. */
52859     JITTER_INSTRUCTION_EPILOG_(*primitive-one-plus/fR*-no-fast-branches, _Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches, 0)
52860 
52861     /* Relocated code will jump to this label in non-relocated code. */
52862   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
52863     JITTER_COMMENT_IN_ASM_("*primitive-one-plus/fR*-no-fast-branches non-relocatable code");
52864 #endif // #ifdef JITTER_REPLICATE
52865 #if defined (JITTER_PROFILE_SAMPLE)
52866   JITTER_PROFILE_SAMPLE_UPDATE
52867      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52868       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52869   /* Force the compiler not move sample-profiling instrumentation
52870      beyond this point; this way the actual user code is timed.
52871      This is still not perfect, as residuals are materialised before
52872      we arrive here, but should be adequate at least for slow VM
52873      instructions. */
52874   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
52875 #endif
52876 #if defined (JITTER_PROFILE_COUNT)
52877   /* Notice that, differently from the code above, this
52878      instrumentation code *can* be reordered freely: as long as a
52879      VM instruction is counted, the count increment can be placed
52880      anyehere.  Let GCC move this code and possibly achieve better
52881      throughput by exploiting instruction-level parallelism and
52882      therefore approximate more closely a non-profiled build. */
52883   JITTER_PROFILE_COUNT_UPDATE
52884      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
52885       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
52886 #endif
52887 
52888 /* User-specified code, instruction-beginning-c part: beginning. */
52889 
52890 
52891 /* User-specified code, instruction-beginning-c part: end */
52892 
52893 
52894     /* User code for *primitive-one-plus/fR*-no-fast-branches . */
52895 
52896     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
52897     JITTERLISP_1PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
52898                                   JITTER_TOP_MAINSTACK(),
52899                                   JITTER_ARGF0);
52900 
52901     /* End of the user code for *primitive-one-plus/fR*-no-fast-branches . */
52902 
52903 /* User-specified code, instruction-end-c part: beginning. */
52904 
52905 
52906 /* User-specified code, instruction-end-c part: end */
52907 
52908 #ifdef JITTER_REPLICATE
52909     /* Advance the instruction pointer, if any, to skip residuals;
52910        then jump back to replicated code. */
52911     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
52912     JITTER_SKIP_RESIDUALS_;
52913     goto * _jitter_back_to_replicated_code_pointer;
52914 #endif // #ifdef JITTER_REPLICATE
52915 
52916     /* Undefine the *primitive-one-plus/fR*-no-fast-branches argument macros so they can't be used
52917        by mistake in the instruction body coming next. */
52918 #   undef JITTER_SLOW_REGISTER_OFFSET0
52919 #   undef JITTER_ARG0
52920 #   undef JITTER_ARGN0
52921 #   undef JITTER_ARGU0
52922 #   undef JITTER_ARGP0
52923 #   undef JITTER_ARGF0
52924 
52925 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
52926 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
52927 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
52928 
52929   }
52930 #ifndef JITTER_REPLICATE
52931  JITTER_INSTRUCTION_EPILOG_(*primitive-one-plus/fR*-no-fast-branches, _Aprimitive_mone_mplus__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
52932 #endif // #ifndef JITTER_REPLICATE
52933 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
52934 
52935   JITTER_INSTRUCTION_PROLOG_(*primitive-positivep/fR*-no-fast-branches, _Aprimitive_mpositivep__fR_A_mno_mfast_mbranches, hot)
52936   {
52937     /* This specialized instruction is a replacement. */
52938 #   undef JITTER_BRANCH_FAST
52939 #   define JITTER_BRANCH_FAST JITTER_BRANCH
52940 #   undef JITTER_BRANCH_FAST_IF_ZERO
52941 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
52942 #   undef JITTER_BRANCH_FAST_IF_NONZERO
52943 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
52944 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
52945 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
52946 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
52947 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
52948 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
52949 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
52950 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
52951 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
52952 #   undef JITTER_BRANCH_FAST_IF_EQUAL
52953 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
52954 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
52955 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
52956 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
52957 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
52958 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
52959 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
52960 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
52961 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
52962 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
52963 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
52964 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
52965 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
52966 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
52967 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
52968 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
52969 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
52970 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
52971 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
52972 #   undef JITTER_BRANCH_FAST_IF_AND
52973 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
52974 #   undef JITTER_BRANCH_FAST_IF_NOTAND
52975 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
52976 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
52977 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
52978 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
52979 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
52980 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
52981 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
52982 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
52983 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
52984 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
52985 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
52986 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
52987 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
52988 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
52989 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
52990 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
52991 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
52992 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
52993 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
52994 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
52995 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
52996 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
52997 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
52998 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
52999 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
53000 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
53001 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
53002     /* This specialized instruction is non-relocatable.
53003        Its 0-th argument, a literal, is the return address where to jump
53004        at the end, back to relocated code. */
53005 
53006 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       271
53007 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-positivep/fR*-no-fast-branches
53008 
53009 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mpositivep__fR_A_mno_mfast_mbranches
53010 
53011   /* The residual arity for this instruction does not depend on fast labels. */
53012   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
53013 
53014   /* Define argument-access macros for *primitive-positivep/fR*-no-fast-branches . */
53015 #ifdef JITTER_HAVE_PATCH_IN
53016   /* Define argument-access macros assuming that fast branches are enabled. */
53017     /* The 0th argument is a residual label. */
53018 #if defined(JITTER_DISPATCH_NO_THREADING)
53019 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53020     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53021 #elif defined (JITTER_REPLICATE)
53022 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53023 #else
53024 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53025 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53026 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53027 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53028 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53029 #   define JITTER_ARGF0 JITTER_ARGP0
53030 
53031 #else
53032   /* Define argument-access macros assuming that fast branches are disabled. */
53033     /* The 0th argument is a residual label. */
53034 #if defined(JITTER_DISPATCH_NO_THREADING)
53035 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53036     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53037 #elif defined (JITTER_REPLICATE)
53038 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53039 #else
53040 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53041 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53042 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53043 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53044 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53045 #   define JITTER_ARGF0 JITTER_ARGP0
53046 
53047 # endif // #ifdef JITTER_HAVE_PATCH_IN
53048 
53049 #ifdef JITTER_REPLICATE
53050     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
53051        it on the stack rather than in read-only memory.  I had to do this to prevent
53052        a GCC 8 snapshot on SH from being too clever. */
53053     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53054     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
53055        in memory, as a 16-bit constant; and since it reads it with a PC-relative
53056        load the relocated part crashes.
53057                  mov.w     .L1667,r0
53058                  mov.l     @(r0,r15),r1
53059                  jmp       @r1
53060        r15 is the stack pointer.  The constant at .L1667 is
53061           .L1667:
53062                  .short    232
53063        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
53064        can't work as an immediate.  Shall I keep these code pointers as a single array?
53065        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
53066        but the problem will be the same. */
53067     /* Jump to non-relocatable code. */
53068     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53069 
53070     /* Here the residual arity is given as zero: it's too late to
53071        skip residuals, since we've already jumped and this code is
53072        unreachable.  The instruction pointer, if any, is advanced
53073        in the non-relocatable code. */
53074     JITTER_INSTRUCTION_EPILOG_(*primitive-positivep/fR*-no-fast-branches, _Aprimitive_mpositivep__fR_A_mno_mfast_mbranches, 0)
53075 
53076     /* Relocated code will jump to this label in non-relocated code. */
53077   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
53078     JITTER_COMMENT_IN_ASM_("*primitive-positivep/fR*-no-fast-branches non-relocatable code");
53079 #endif // #ifdef JITTER_REPLICATE
53080 #if defined (JITTER_PROFILE_SAMPLE)
53081   JITTER_PROFILE_SAMPLE_UPDATE
53082      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53083       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53084   /* Force the compiler not move sample-profiling instrumentation
53085      beyond this point; this way the actual user code is timed.
53086      This is still not perfect, as residuals are materialised before
53087      we arrive here, but should be adequate at least for slow VM
53088      instructions. */
53089   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
53090 #endif
53091 #if defined (JITTER_PROFILE_COUNT)
53092   /* Notice that, differently from the code above, this
53093      instrumentation code *can* be reordered freely: as long as a
53094      VM instruction is counted, the count increment can be placed
53095      anyehere.  Let GCC move this code and possibly achieve better
53096      throughput by exploiting instruction-level parallelism and
53097      therefore approximate more closely a non-profiled build. */
53098   JITTER_PROFILE_COUNT_UPDATE
53099      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53100       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53101 #endif
53102 
53103 /* User-specified code, instruction-beginning-c part: beginning. */
53104 
53105 
53106 /* User-specified code, instruction-beginning-c part: end */
53107 
53108 
53109     /* User code for *primitive-positivep/fR*-no-fast-branches . */
53110 
53111     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
53112     JITTERLISP_POSITIVEP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
53113 
53114     /* End of the user code for *primitive-positivep/fR*-no-fast-branches . */
53115 
53116 /* User-specified code, instruction-end-c part: beginning. */
53117 
53118 
53119 /* User-specified code, instruction-end-c part: end */
53120 
53121 #ifdef JITTER_REPLICATE
53122     /* Advance the instruction pointer, if any, to skip residuals;
53123        then jump back to replicated code. */
53124     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
53125     JITTER_SKIP_RESIDUALS_;
53126     goto * _jitter_back_to_replicated_code_pointer;
53127 #endif // #ifdef JITTER_REPLICATE
53128 
53129     /* Undefine the *primitive-positivep/fR*-no-fast-branches argument macros so they can't be used
53130        by mistake in the instruction body coming next. */
53131 #   undef JITTER_SLOW_REGISTER_OFFSET0
53132 #   undef JITTER_ARG0
53133 #   undef JITTER_ARGN0
53134 #   undef JITTER_ARGU0
53135 #   undef JITTER_ARGP0
53136 #   undef JITTER_ARGF0
53137 
53138 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
53139 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
53140 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
53141 
53142   }
53143 #ifndef JITTER_REPLICATE
53144  JITTER_INSTRUCTION_EPILOG_(*primitive-positivep/fR*-no-fast-branches, _Aprimitive_mpositivep__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
53145 #endif // #ifndef JITTER_REPLICATE
53146 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
53147 
53148   JITTER_INSTRUCTION_PROLOG_(*primitive-primordial-divided/fR*-no-fast-branches, _Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches, hot)
53149   {
53150     /* This specialized instruction is a replacement. */
53151 #   undef JITTER_BRANCH_FAST
53152 #   define JITTER_BRANCH_FAST JITTER_BRANCH
53153 #   undef JITTER_BRANCH_FAST_IF_ZERO
53154 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
53155 #   undef JITTER_BRANCH_FAST_IF_NONZERO
53156 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
53157 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
53158 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
53159 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
53160 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
53161 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
53162 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
53163 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
53164 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
53165 #   undef JITTER_BRANCH_FAST_IF_EQUAL
53166 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
53167 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
53168 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
53169 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
53170 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
53171 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
53172 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
53173 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
53174 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
53175 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
53176 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
53177 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
53178 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
53179 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
53180 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
53181 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
53182 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
53183 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
53184 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
53185 #   undef JITTER_BRANCH_FAST_IF_AND
53186 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
53187 #   undef JITTER_BRANCH_FAST_IF_NOTAND
53188 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
53189 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
53190 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
53191 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
53192 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
53193 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
53194 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
53195 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
53196 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
53197 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
53198 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
53199 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
53200 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
53201 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
53202 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
53203 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
53204 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
53205 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
53206 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
53207 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
53208 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
53209 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
53210 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
53211 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
53212 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
53213 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
53214 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
53215     /* This specialized instruction is non-relocatable.
53216        Its 0-th argument, a literal, is the return address where to jump
53217        at the end, back to relocated code. */
53218 
53219 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       272
53220 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-primordial-divided/fR*-no-fast-branches
53221 
53222 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches
53223 
53224   /* The residual arity for this instruction does not depend on fast labels. */
53225   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
53226 
53227   /* Define argument-access macros for *primitive-primordial-divided/fR*-no-fast-branches . */
53228 #ifdef JITTER_HAVE_PATCH_IN
53229   /* Define argument-access macros assuming that fast branches are enabled. */
53230     /* The 0th argument is a residual label. */
53231 #if defined(JITTER_DISPATCH_NO_THREADING)
53232 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53233     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53234 #elif defined (JITTER_REPLICATE)
53235 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53236 #else
53237 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53238 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53239 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53240 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53241 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53242 #   define JITTER_ARGF0 JITTER_ARGP0
53243 
53244 #else
53245   /* Define argument-access macros assuming that fast branches are disabled. */
53246     /* The 0th argument is a residual label. */
53247 #if defined(JITTER_DISPATCH_NO_THREADING)
53248 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53249     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53250 #elif defined (JITTER_REPLICATE)
53251 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53252 #else
53253 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53254 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53255 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53256 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53257 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53258 #   define JITTER_ARGF0 JITTER_ARGP0
53259 
53260 # endif // #ifdef JITTER_HAVE_PATCH_IN
53261 
53262 #ifdef JITTER_REPLICATE
53263     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
53264        it on the stack rather than in read-only memory.  I had to do this to prevent
53265        a GCC 8 snapshot on SH from being too clever. */
53266     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53267     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
53268        in memory, as a 16-bit constant; and since it reads it with a PC-relative
53269        load the relocated part crashes.
53270                  mov.w     .L1667,r0
53271                  mov.l     @(r0,r15),r1
53272                  jmp       @r1
53273        r15 is the stack pointer.  The constant at .L1667 is
53274           .L1667:
53275                  .short    232
53276        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
53277        can't work as an immediate.  Shall I keep these code pointers as a single array?
53278        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
53279        but the problem will be the same. */
53280     /* Jump to non-relocatable code. */
53281     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53282 
53283     /* Here the residual arity is given as zero: it's too late to
53284        skip residuals, since we've already jumped and this code is
53285        unreachable.  The instruction pointer, if any, is advanced
53286        in the non-relocatable code. */
53287     JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-divided/fR*-no-fast-branches, _Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches, 0)
53288 
53289     /* Relocated code will jump to this label in non-relocated code. */
53290   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
53291     JITTER_COMMENT_IN_ASM_("*primitive-primordial-divided/fR*-no-fast-branches non-relocatable code");
53292 #endif // #ifdef JITTER_REPLICATE
53293 #if defined (JITTER_PROFILE_SAMPLE)
53294   JITTER_PROFILE_SAMPLE_UPDATE
53295      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53296       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53297   /* Force the compiler not move sample-profiling instrumentation
53298      beyond this point; this way the actual user code is timed.
53299      This is still not perfect, as residuals are materialised before
53300      we arrive here, but should be adequate at least for slow VM
53301      instructions. */
53302   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
53303 #endif
53304 #if defined (JITTER_PROFILE_COUNT)
53305   /* Notice that, differently from the code above, this
53306      instrumentation code *can* be reordered freely: as long as a
53307      VM instruction is counted, the count increment can be placed
53308      anyehere.  Let GCC move this code and possibly achieve better
53309      throughput by exploiting instruction-level parallelism and
53310      therefore approximate more closely a non-profiled build. */
53311   JITTER_PROFILE_COUNT_UPDATE
53312      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53313       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53314 #endif
53315 
53316 /* User-specified code, instruction-beginning-c part: beginning. */
53317 
53318 
53319 /* User-specified code, instruction-beginning-c part: end */
53320 
53321 
53322     /* User code for *primitive-primordial-divided/fR*-no-fast-branches . */
53323 
53324     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
53325     JITTERLISP_DIVIDED_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
53326                                     JITTER_UNDER_TOP_MAINSTACK(),
53327                                     JITTER_TOP_MAINSTACK(),
53328                                     JITTER_ARGF0);
53329     JITTER_NIP_MAINSTACK();
53330 
53331     /* End of the user code for *primitive-primordial-divided/fR*-no-fast-branches . */
53332 
53333 /* User-specified code, instruction-end-c part: beginning. */
53334 
53335 
53336 /* User-specified code, instruction-end-c part: end */
53337 
53338 #ifdef JITTER_REPLICATE
53339     /* Advance the instruction pointer, if any, to skip residuals;
53340        then jump back to replicated code. */
53341     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
53342     JITTER_SKIP_RESIDUALS_;
53343     goto * _jitter_back_to_replicated_code_pointer;
53344 #endif // #ifdef JITTER_REPLICATE
53345 
53346     /* Undefine the *primitive-primordial-divided/fR*-no-fast-branches argument macros so they can't be used
53347        by mistake in the instruction body coming next. */
53348 #   undef JITTER_SLOW_REGISTER_OFFSET0
53349 #   undef JITTER_ARG0
53350 #   undef JITTER_ARGN0
53351 #   undef JITTER_ARGU0
53352 #   undef JITTER_ARGP0
53353 #   undef JITTER_ARGF0
53354 
53355 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
53356 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
53357 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
53358 
53359   }
53360 #ifndef JITTER_REPLICATE
53361  JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-divided/fR*-no-fast-branches, _Aprimitive_mprimordial_mdivided__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
53362 #endif // #ifndef JITTER_REPLICATE
53363 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
53364 
53365   JITTER_INSTRUCTION_PROLOG_(*primitive-primordial-divided-unsafe/fR*-no-fast-branches, _Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches, hot)
53366   {
53367     /* This specialized instruction is a replacement. */
53368 #   undef JITTER_BRANCH_FAST
53369 #   define JITTER_BRANCH_FAST JITTER_BRANCH
53370 #   undef JITTER_BRANCH_FAST_IF_ZERO
53371 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
53372 #   undef JITTER_BRANCH_FAST_IF_NONZERO
53373 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
53374 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
53375 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
53376 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
53377 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
53378 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
53379 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
53380 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
53381 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
53382 #   undef JITTER_BRANCH_FAST_IF_EQUAL
53383 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
53384 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
53385 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
53386 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
53387 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
53388 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
53389 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
53390 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
53391 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
53392 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
53393 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
53394 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
53395 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
53396 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
53397 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
53398 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
53399 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
53400 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
53401 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
53402 #   undef JITTER_BRANCH_FAST_IF_AND
53403 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
53404 #   undef JITTER_BRANCH_FAST_IF_NOTAND
53405 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
53406 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
53407 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
53408 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
53409 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
53410 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
53411 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
53412 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
53413 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
53414 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
53415 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
53416 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
53417 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
53418 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
53419 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
53420 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
53421 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
53422 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
53423 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
53424 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
53425 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
53426 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
53427 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
53428 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
53429 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
53430 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
53431 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
53432     /* This specialized instruction is non-relocatable.
53433        Its 0-th argument, a literal, is the return address where to jump
53434        at the end, back to relocated code. */
53435 
53436 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       273
53437 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-primordial-divided-unsafe/fR*-no-fast-branches
53438 
53439 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches
53440 
53441   /* The residual arity for this instruction does not depend on fast labels. */
53442   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
53443 
53444   /* Define argument-access macros for *primitive-primordial-divided-unsafe/fR*-no-fast-branches . */
53445 #ifdef JITTER_HAVE_PATCH_IN
53446   /* Define argument-access macros assuming that fast branches are enabled. */
53447     /* The 0th argument is a residual label. */
53448 #if defined(JITTER_DISPATCH_NO_THREADING)
53449 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53450     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53451 #elif defined (JITTER_REPLICATE)
53452 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53453 #else
53454 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53455 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53456 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53457 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53458 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53459 #   define JITTER_ARGF0 JITTER_ARGP0
53460 
53461 #else
53462   /* Define argument-access macros assuming that fast branches are disabled. */
53463     /* The 0th argument is a residual label. */
53464 #if defined(JITTER_DISPATCH_NO_THREADING)
53465 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53466     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53467 #elif defined (JITTER_REPLICATE)
53468 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53469 #else
53470 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53471 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53472 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53473 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53474 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53475 #   define JITTER_ARGF0 JITTER_ARGP0
53476 
53477 # endif // #ifdef JITTER_HAVE_PATCH_IN
53478 
53479 #ifdef JITTER_REPLICATE
53480     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
53481        it on the stack rather than in read-only memory.  I had to do this to prevent
53482        a GCC 8 snapshot on SH from being too clever. */
53483     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53484     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
53485        in memory, as a 16-bit constant; and since it reads it with a PC-relative
53486        load the relocated part crashes.
53487                  mov.w     .L1667,r0
53488                  mov.l     @(r0,r15),r1
53489                  jmp       @r1
53490        r15 is the stack pointer.  The constant at .L1667 is
53491           .L1667:
53492                  .short    232
53493        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
53494        can't work as an immediate.  Shall I keep these code pointers as a single array?
53495        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
53496        but the problem will be the same. */
53497     /* Jump to non-relocatable code. */
53498     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53499 
53500     /* Here the residual arity is given as zero: it's too late to
53501        skip residuals, since we've already jumped and this code is
53502        unreachable.  The instruction pointer, if any, is advanced
53503        in the non-relocatable code. */
53504     JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-divided-unsafe/fR*-no-fast-branches, _Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches, 0)
53505 
53506     /* Relocated code will jump to this label in non-relocated code. */
53507   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
53508     JITTER_COMMENT_IN_ASM_("*primitive-primordial-divided-unsafe/fR*-no-fast-branches non-relocatable code");
53509 #endif // #ifdef JITTER_REPLICATE
53510 #if defined (JITTER_PROFILE_SAMPLE)
53511   JITTER_PROFILE_SAMPLE_UPDATE
53512      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53513       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53514   /* Force the compiler not move sample-profiling instrumentation
53515      beyond this point; this way the actual user code is timed.
53516      This is still not perfect, as residuals are materialised before
53517      we arrive here, but should be adequate at least for slow VM
53518      instructions. */
53519   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
53520 #endif
53521 #if defined (JITTER_PROFILE_COUNT)
53522   /* Notice that, differently from the code above, this
53523      instrumentation code *can* be reordered freely: as long as a
53524      VM instruction is counted, the count increment can be placed
53525      anyehere.  Let GCC move this code and possibly achieve better
53526      throughput by exploiting instruction-level parallelism and
53527      therefore approximate more closely a non-profiled build. */
53528   JITTER_PROFILE_COUNT_UPDATE
53529      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53530       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53531 #endif
53532 
53533 /* User-specified code, instruction-beginning-c part: beginning. */
53534 
53535 
53536 /* User-specified code, instruction-beginning-c part: end */
53537 
53538 
53539     /* User code for *primitive-primordial-divided-unsafe/fR*-no-fast-branches . */
53540 
53541     /* The second argument has already been validated if we are using this. */
53542     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
53543     JITTERLISP_DIVIDED_UNSAFE_(JITTER_TOP_MAINSTACK(),
53544                                JITTER_UNDER_TOP_MAINSTACK(),
53545                                JITTER_TOP_MAINSTACK());
53546     JITTER_NIP_MAINSTACK();
53547 
53548     /* End of the user code for *primitive-primordial-divided-unsafe/fR*-no-fast-branches . */
53549 
53550 /* User-specified code, instruction-end-c part: beginning. */
53551 
53552 
53553 /* User-specified code, instruction-end-c part: end */
53554 
53555 #ifdef JITTER_REPLICATE
53556     /* Advance the instruction pointer, if any, to skip residuals;
53557        then jump back to replicated code. */
53558     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
53559     JITTER_SKIP_RESIDUALS_;
53560     goto * _jitter_back_to_replicated_code_pointer;
53561 #endif // #ifdef JITTER_REPLICATE
53562 
53563     /* Undefine the *primitive-primordial-divided-unsafe/fR*-no-fast-branches argument macros so they can't be used
53564        by mistake in the instruction body coming next. */
53565 #   undef JITTER_SLOW_REGISTER_OFFSET0
53566 #   undef JITTER_ARG0
53567 #   undef JITTER_ARGN0
53568 #   undef JITTER_ARGU0
53569 #   undef JITTER_ARGP0
53570 #   undef JITTER_ARGF0
53571 
53572 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
53573 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
53574 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
53575 
53576   }
53577 #ifndef JITTER_REPLICATE
53578  JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-divided-unsafe/fR*-no-fast-branches, _Aprimitive_mprimordial_mdivided_munsafe__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
53579 #endif // #ifndef JITTER_REPLICATE
53580 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
53581 
53582   JITTER_INSTRUCTION_PROLOG_(*primitive-primordial-minus/fR*-no-fast-branches, _Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches, hot)
53583   {
53584     /* This specialized instruction is a replacement. */
53585 #   undef JITTER_BRANCH_FAST
53586 #   define JITTER_BRANCH_FAST JITTER_BRANCH
53587 #   undef JITTER_BRANCH_FAST_IF_ZERO
53588 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
53589 #   undef JITTER_BRANCH_FAST_IF_NONZERO
53590 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
53591 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
53592 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
53593 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
53594 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
53595 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
53596 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
53597 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
53598 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
53599 #   undef JITTER_BRANCH_FAST_IF_EQUAL
53600 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
53601 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
53602 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
53603 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
53604 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
53605 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
53606 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
53607 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
53608 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
53609 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
53610 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
53611 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
53612 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
53613 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
53614 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
53615 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
53616 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
53617 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
53618 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
53619 #   undef JITTER_BRANCH_FAST_IF_AND
53620 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
53621 #   undef JITTER_BRANCH_FAST_IF_NOTAND
53622 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
53623 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
53624 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
53625 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
53626 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
53627 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
53628 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
53629 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
53630 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
53631 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
53632 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
53633 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
53634 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
53635 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
53636 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
53637 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
53638 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
53639 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
53640 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
53641 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
53642 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
53643 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
53644 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
53645 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
53646 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
53647 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
53648 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
53649     /* This specialized instruction is non-relocatable.
53650        Its 0-th argument, a literal, is the return address where to jump
53651        at the end, back to relocated code. */
53652 
53653 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       274
53654 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-primordial-minus/fR*-no-fast-branches
53655 
53656 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches
53657 
53658   /* The residual arity for this instruction does not depend on fast labels. */
53659   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
53660 
53661   /* Define argument-access macros for *primitive-primordial-minus/fR*-no-fast-branches . */
53662 #ifdef JITTER_HAVE_PATCH_IN
53663   /* Define argument-access macros assuming that fast branches are enabled. */
53664     /* The 0th argument is a residual label. */
53665 #if defined(JITTER_DISPATCH_NO_THREADING)
53666 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53667     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53668 #elif defined (JITTER_REPLICATE)
53669 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53670 #else
53671 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53672 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53673 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53674 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53675 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53676 #   define JITTER_ARGF0 JITTER_ARGP0
53677 
53678 #else
53679   /* Define argument-access macros assuming that fast branches are disabled. */
53680     /* The 0th argument is a residual label. */
53681 #if defined(JITTER_DISPATCH_NO_THREADING)
53682 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53683     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53684 #elif defined (JITTER_REPLICATE)
53685 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53686 #else
53687 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53688 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53689 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53690 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53691 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53692 #   define JITTER_ARGF0 JITTER_ARGP0
53693 
53694 # endif // #ifdef JITTER_HAVE_PATCH_IN
53695 
53696 #ifdef JITTER_REPLICATE
53697     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
53698        it on the stack rather than in read-only memory.  I had to do this to prevent
53699        a GCC 8 snapshot on SH from being too clever. */
53700     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53701     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
53702        in memory, as a 16-bit constant; and since it reads it with a PC-relative
53703        load the relocated part crashes.
53704                  mov.w     .L1667,r0
53705                  mov.l     @(r0,r15),r1
53706                  jmp       @r1
53707        r15 is the stack pointer.  The constant at .L1667 is
53708           .L1667:
53709                  .short    232
53710        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
53711        can't work as an immediate.  Shall I keep these code pointers as a single array?
53712        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
53713        but the problem will be the same. */
53714     /* Jump to non-relocatable code. */
53715     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53716 
53717     /* Here the residual arity is given as zero: it's too late to
53718        skip residuals, since we've already jumped and this code is
53719        unreachable.  The instruction pointer, if any, is advanced
53720        in the non-relocatable code. */
53721     JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-minus/fR*-no-fast-branches, _Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches, 0)
53722 
53723     /* Relocated code will jump to this label in non-relocated code. */
53724   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
53725     JITTER_COMMENT_IN_ASM_("*primitive-primordial-minus/fR*-no-fast-branches non-relocatable code");
53726 #endif // #ifdef JITTER_REPLICATE
53727 #if defined (JITTER_PROFILE_SAMPLE)
53728   JITTER_PROFILE_SAMPLE_UPDATE
53729      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53730       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53731   /* Force the compiler not move sample-profiling instrumentation
53732      beyond this point; this way the actual user code is timed.
53733      This is still not perfect, as residuals are materialised before
53734      we arrive here, but should be adequate at least for slow VM
53735      instructions. */
53736   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
53737 #endif
53738 #if defined (JITTER_PROFILE_COUNT)
53739   /* Notice that, differently from the code above, this
53740      instrumentation code *can* be reordered freely: as long as a
53741      VM instruction is counted, the count increment can be placed
53742      anyehere.  Let GCC move this code and possibly achieve better
53743      throughput by exploiting instruction-level parallelism and
53744      therefore approximate more closely a non-profiled build. */
53745   JITTER_PROFILE_COUNT_UPDATE
53746      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53747       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53748 #endif
53749 
53750 /* User-specified code, instruction-beginning-c part: beginning. */
53751 
53752 
53753 /* User-specified code, instruction-beginning-c part: end */
53754 
53755 
53756     /* User code for *primitive-primordial-minus/fR*-no-fast-branches . */
53757 
53758     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
53759     JITTERLISP_MINUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
53760                                   JITTER_UNDER_TOP_MAINSTACK(),
53761                                   JITTER_TOP_MAINSTACK(),
53762                                   JITTER_ARGF0);
53763     JITTER_NIP_MAINSTACK();
53764 
53765     /* End of the user code for *primitive-primordial-minus/fR*-no-fast-branches . */
53766 
53767 /* User-specified code, instruction-end-c part: beginning. */
53768 
53769 
53770 /* User-specified code, instruction-end-c part: end */
53771 
53772 #ifdef JITTER_REPLICATE
53773     /* Advance the instruction pointer, if any, to skip residuals;
53774        then jump back to replicated code. */
53775     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
53776     JITTER_SKIP_RESIDUALS_;
53777     goto * _jitter_back_to_replicated_code_pointer;
53778 #endif // #ifdef JITTER_REPLICATE
53779 
53780     /* Undefine the *primitive-primordial-minus/fR*-no-fast-branches argument macros so they can't be used
53781        by mistake in the instruction body coming next. */
53782 #   undef JITTER_SLOW_REGISTER_OFFSET0
53783 #   undef JITTER_ARG0
53784 #   undef JITTER_ARGN0
53785 #   undef JITTER_ARGU0
53786 #   undef JITTER_ARGP0
53787 #   undef JITTER_ARGF0
53788 
53789 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
53790 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
53791 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
53792 
53793   }
53794 #ifndef JITTER_REPLICATE
53795  JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-minus/fR*-no-fast-branches, _Aprimitive_mprimordial_mminus__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
53796 #endif // #ifndef JITTER_REPLICATE
53797 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
53798 
53799   JITTER_INSTRUCTION_PROLOG_(*primitive-primordial-plus/fR*-no-fast-branches, _Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches, hot)
53800   {
53801     /* This specialized instruction is a replacement. */
53802 #   undef JITTER_BRANCH_FAST
53803 #   define JITTER_BRANCH_FAST JITTER_BRANCH
53804 #   undef JITTER_BRANCH_FAST_IF_ZERO
53805 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
53806 #   undef JITTER_BRANCH_FAST_IF_NONZERO
53807 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
53808 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
53809 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
53810 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
53811 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
53812 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
53813 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
53814 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
53815 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
53816 #   undef JITTER_BRANCH_FAST_IF_EQUAL
53817 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
53818 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
53819 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
53820 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
53821 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
53822 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
53823 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
53824 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
53825 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
53826 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
53827 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
53828 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
53829 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
53830 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
53831 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
53832 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
53833 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
53834 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
53835 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
53836 #   undef JITTER_BRANCH_FAST_IF_AND
53837 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
53838 #   undef JITTER_BRANCH_FAST_IF_NOTAND
53839 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
53840 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
53841 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
53842 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
53843 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
53844 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
53845 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
53846 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
53847 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
53848 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
53849 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
53850 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
53851 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
53852 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
53853 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
53854 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
53855 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
53856 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
53857 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
53858 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
53859 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
53860 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
53861 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
53862 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
53863 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
53864 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
53865 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
53866     /* This specialized instruction is non-relocatable.
53867        Its 0-th argument, a literal, is the return address where to jump
53868        at the end, back to relocated code. */
53869 
53870 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       275
53871 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-primordial-plus/fR*-no-fast-branches
53872 
53873 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches
53874 
53875   /* The residual arity for this instruction does not depend on fast labels. */
53876   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
53877 
53878   /* Define argument-access macros for *primitive-primordial-plus/fR*-no-fast-branches . */
53879 #ifdef JITTER_HAVE_PATCH_IN
53880   /* Define argument-access macros assuming that fast branches are enabled. */
53881     /* The 0th argument is a residual label. */
53882 #if defined(JITTER_DISPATCH_NO_THREADING)
53883 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53884     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53885 #elif defined (JITTER_REPLICATE)
53886 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53887 #else
53888 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53889 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53890 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53891 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53892 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53893 #   define JITTER_ARGF0 JITTER_ARGP0
53894 
53895 #else
53896   /* Define argument-access macros assuming that fast branches are disabled. */
53897     /* The 0th argument is a residual label. */
53898 #if defined(JITTER_DISPATCH_NO_THREADING)
53899 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
53900     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
53901 #elif defined (JITTER_REPLICATE)
53902 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
53903 #else
53904 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
53905 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
53906 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
53907 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
53908 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
53909 #   define JITTER_ARGF0 JITTER_ARGP0
53910 
53911 # endif // #ifdef JITTER_HAVE_PATCH_IN
53912 
53913 #ifdef JITTER_REPLICATE
53914     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
53915        it on the stack rather than in read-only memory.  I had to do this to prevent
53916        a GCC 8 snapshot on SH from being too clever. */
53917     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53918     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
53919        in memory, as a 16-bit constant; and since it reads it with a PC-relative
53920        load the relocated part crashes.
53921                  mov.w     .L1667,r0
53922                  mov.l     @(r0,r15),r1
53923                  jmp       @r1
53924        r15 is the stack pointer.  The constant at .L1667 is
53925           .L1667:
53926                  .short    232
53927        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
53928        can't work as an immediate.  Shall I keep these code pointers as a single array?
53929        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
53930        but the problem will be the same. */
53931     /* Jump to non-relocatable code. */
53932     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
53933 
53934     /* Here the residual arity is given as zero: it's too late to
53935        skip residuals, since we've already jumped and this code is
53936        unreachable.  The instruction pointer, if any, is advanced
53937        in the non-relocatable code. */
53938     JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-plus/fR*-no-fast-branches, _Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches, 0)
53939 
53940     /* Relocated code will jump to this label in non-relocated code. */
53941   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
53942     JITTER_COMMENT_IN_ASM_("*primitive-primordial-plus/fR*-no-fast-branches non-relocatable code");
53943 #endif // #ifdef JITTER_REPLICATE
53944 #if defined (JITTER_PROFILE_SAMPLE)
53945   JITTER_PROFILE_SAMPLE_UPDATE
53946      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53947       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53948   /* Force the compiler not move sample-profiling instrumentation
53949      beyond this point; this way the actual user code is timed.
53950      This is still not perfect, as residuals are materialised before
53951      we arrive here, but should be adequate at least for slow VM
53952      instructions. */
53953   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
53954 #endif
53955 #if defined (JITTER_PROFILE_COUNT)
53956   /* Notice that, differently from the code above, this
53957      instrumentation code *can* be reordered freely: as long as a
53958      VM instruction is counted, the count increment can be placed
53959      anyehere.  Let GCC move this code and possibly achieve better
53960      throughput by exploiting instruction-level parallelism and
53961      therefore approximate more closely a non-profiled build. */
53962   JITTER_PROFILE_COUNT_UPDATE
53963      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
53964       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
53965 #endif
53966 
53967 /* User-specified code, instruction-beginning-c part: beginning. */
53968 
53969 
53970 /* User-specified code, instruction-beginning-c part: end */
53971 
53972 
53973     /* User code for *primitive-primordial-plus/fR*-no-fast-branches . */
53974 
53975     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
53976     JITTERLISP_PLUS_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
53977                                  JITTER_UNDER_TOP_MAINSTACK(),
53978                                  JITTER_TOP_MAINSTACK(),
53979                                  JITTER_ARGF0);
53980     JITTER_NIP_MAINSTACK();
53981 
53982     /* End of the user code for *primitive-primordial-plus/fR*-no-fast-branches . */
53983 
53984 /* User-specified code, instruction-end-c part: beginning. */
53985 
53986 
53987 /* User-specified code, instruction-end-c part: end */
53988 
53989 #ifdef JITTER_REPLICATE
53990     /* Advance the instruction pointer, if any, to skip residuals;
53991        then jump back to replicated code. */
53992     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
53993     JITTER_SKIP_RESIDUALS_;
53994     goto * _jitter_back_to_replicated_code_pointer;
53995 #endif // #ifdef JITTER_REPLICATE
53996 
53997     /* Undefine the *primitive-primordial-plus/fR*-no-fast-branches argument macros so they can't be used
53998        by mistake in the instruction body coming next. */
53999 #   undef JITTER_SLOW_REGISTER_OFFSET0
54000 #   undef JITTER_ARG0
54001 #   undef JITTER_ARGN0
54002 #   undef JITTER_ARGU0
54003 #   undef JITTER_ARGP0
54004 #   undef JITTER_ARGF0
54005 
54006 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
54007 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
54008 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
54009 
54010   }
54011 #ifndef JITTER_REPLICATE
54012  JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-plus/fR*-no-fast-branches, _Aprimitive_mprimordial_mplus__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
54013 #endif // #ifndef JITTER_REPLICATE
54014 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
54015 
54016   JITTER_INSTRUCTION_PROLOG_(*primitive-primordial-times/fR*-no-fast-branches, _Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches, hot)
54017   {
54018     /* This specialized instruction is a replacement. */
54019 #   undef JITTER_BRANCH_FAST
54020 #   define JITTER_BRANCH_FAST JITTER_BRANCH
54021 #   undef JITTER_BRANCH_FAST_IF_ZERO
54022 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
54023 #   undef JITTER_BRANCH_FAST_IF_NONZERO
54024 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
54025 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
54026 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
54027 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
54028 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
54029 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
54030 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
54031 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
54032 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
54033 #   undef JITTER_BRANCH_FAST_IF_EQUAL
54034 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
54035 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
54036 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
54037 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
54038 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
54039 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
54040 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
54041 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
54042 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
54043 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
54044 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
54045 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
54046 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
54047 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
54048 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
54049 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
54050 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
54051 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
54052 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
54053 #   undef JITTER_BRANCH_FAST_IF_AND
54054 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
54055 #   undef JITTER_BRANCH_FAST_IF_NOTAND
54056 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
54057 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
54058 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
54059 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
54060 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
54061 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
54062 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
54063 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
54064 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
54065 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
54066 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
54067 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
54068 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
54069 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
54070 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
54071 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
54072 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
54073 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
54074 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
54075 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
54076 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
54077 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
54078 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
54079 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
54080 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
54081 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
54082 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
54083     /* This specialized instruction is non-relocatable.
54084        Its 0-th argument, a literal, is the return address where to jump
54085        at the end, back to relocated code. */
54086 
54087 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       276
54088 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-primordial-times/fR*-no-fast-branches
54089 
54090 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches
54091 
54092   /* The residual arity for this instruction does not depend on fast labels. */
54093   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
54094 
54095   /* Define argument-access macros for *primitive-primordial-times/fR*-no-fast-branches . */
54096 #ifdef JITTER_HAVE_PATCH_IN
54097   /* Define argument-access macros assuming that fast branches are enabled. */
54098     /* The 0th argument is a residual label. */
54099 #if defined(JITTER_DISPATCH_NO_THREADING)
54100 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54101     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54102 #elif defined (JITTER_REPLICATE)
54103 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54104 #else
54105 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54106 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54107 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54108 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54109 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54110 #   define JITTER_ARGF0 JITTER_ARGP0
54111 
54112 #else
54113   /* Define argument-access macros assuming that fast branches are disabled. */
54114     /* The 0th argument is a residual label. */
54115 #if defined(JITTER_DISPATCH_NO_THREADING)
54116 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54117     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54118 #elif defined (JITTER_REPLICATE)
54119 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54120 #else
54121 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54122 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54123 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54124 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54125 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54126 #   define JITTER_ARGF0 JITTER_ARGP0
54127 
54128 # endif // #ifdef JITTER_HAVE_PATCH_IN
54129 
54130 #ifdef JITTER_REPLICATE
54131     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
54132        it on the stack rather than in read-only memory.  I had to do this to prevent
54133        a GCC 8 snapshot on SH from being too clever. */
54134     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54135     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
54136        in memory, as a 16-bit constant; and since it reads it with a PC-relative
54137        load the relocated part crashes.
54138                  mov.w     .L1667,r0
54139                  mov.l     @(r0,r15),r1
54140                  jmp       @r1
54141        r15 is the stack pointer.  The constant at .L1667 is
54142           .L1667:
54143                  .short    232
54144        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
54145        can't work as an immediate.  Shall I keep these code pointers as a single array?
54146        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
54147        but the problem will be the same. */
54148     /* Jump to non-relocatable code. */
54149     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54150 
54151     /* Here the residual arity is given as zero: it's too late to
54152        skip residuals, since we've already jumped and this code is
54153        unreachable.  The instruction pointer, if any, is advanced
54154        in the non-relocatable code. */
54155     JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-times/fR*-no-fast-branches, _Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches, 0)
54156 
54157     /* Relocated code will jump to this label in non-relocated code. */
54158   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
54159     JITTER_COMMENT_IN_ASM_("*primitive-primordial-times/fR*-no-fast-branches non-relocatable code");
54160 #endif // #ifdef JITTER_REPLICATE
54161 #if defined (JITTER_PROFILE_SAMPLE)
54162   JITTER_PROFILE_SAMPLE_UPDATE
54163      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54164       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54165   /* Force the compiler not move sample-profiling instrumentation
54166      beyond this point; this way the actual user code is timed.
54167      This is still not perfect, as residuals are materialised before
54168      we arrive here, but should be adequate at least for slow VM
54169      instructions. */
54170   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
54171 #endif
54172 #if defined (JITTER_PROFILE_COUNT)
54173   /* Notice that, differently from the code above, this
54174      instrumentation code *can* be reordered freely: as long as a
54175      VM instruction is counted, the count increment can be placed
54176      anyehere.  Let GCC move this code and possibly achieve better
54177      throughput by exploiting instruction-level parallelism and
54178      therefore approximate more closely a non-profiled build. */
54179   JITTER_PROFILE_COUNT_UPDATE
54180      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54181       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54182 #endif
54183 
54184 /* User-specified code, instruction-beginning-c part: beginning. */
54185 
54186 
54187 /* User-specified code, instruction-beginning-c part: end */
54188 
54189 
54190     /* User code for *primitive-primordial-times/fR*-no-fast-branches . */
54191 
54192     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
54193     JITTERLISP_TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
54194                                   JITTER_UNDER_TOP_MAINSTACK(),
54195                                   JITTER_TOP_MAINSTACK(),
54196                                   JITTER_ARGF0);
54197     JITTER_NIP_MAINSTACK();
54198 
54199     /* End of the user code for *primitive-primordial-times/fR*-no-fast-branches . */
54200 
54201 /* User-specified code, instruction-end-c part: beginning. */
54202 
54203 
54204 /* User-specified code, instruction-end-c part: end */
54205 
54206 #ifdef JITTER_REPLICATE
54207     /* Advance the instruction pointer, if any, to skip residuals;
54208        then jump back to replicated code. */
54209     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
54210     JITTER_SKIP_RESIDUALS_;
54211     goto * _jitter_back_to_replicated_code_pointer;
54212 #endif // #ifdef JITTER_REPLICATE
54213 
54214     /* Undefine the *primitive-primordial-times/fR*-no-fast-branches argument macros so they can't be used
54215        by mistake in the instruction body coming next. */
54216 #   undef JITTER_SLOW_REGISTER_OFFSET0
54217 #   undef JITTER_ARG0
54218 #   undef JITTER_ARGN0
54219 #   undef JITTER_ARGU0
54220 #   undef JITTER_ARGP0
54221 #   undef JITTER_ARGF0
54222 
54223 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
54224 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
54225 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
54226 
54227   }
54228 #ifndef JITTER_REPLICATE
54229  JITTER_INSTRUCTION_EPILOG_(*primitive-primordial-times/fR*-no-fast-branches, _Aprimitive_mprimordial_mtimes__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
54230 #endif // #ifndef JITTER_REPLICATE
54231 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
54232 
54233   JITTER_INSTRUCTION_PROLOG_(*primitive-quotient/fR*-no-fast-branches, _Aprimitive_mquotient__fR_A_mno_mfast_mbranches, hot)
54234   {
54235     /* This specialized instruction is a replacement. */
54236 #   undef JITTER_BRANCH_FAST
54237 #   define JITTER_BRANCH_FAST JITTER_BRANCH
54238 #   undef JITTER_BRANCH_FAST_IF_ZERO
54239 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
54240 #   undef JITTER_BRANCH_FAST_IF_NONZERO
54241 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
54242 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
54243 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
54244 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
54245 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
54246 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
54247 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
54248 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
54249 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
54250 #   undef JITTER_BRANCH_FAST_IF_EQUAL
54251 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
54252 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
54253 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
54254 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
54255 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
54256 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
54257 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
54258 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
54259 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
54260 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
54261 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
54262 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
54263 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
54264 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
54265 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
54266 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
54267 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
54268 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
54269 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
54270 #   undef JITTER_BRANCH_FAST_IF_AND
54271 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
54272 #   undef JITTER_BRANCH_FAST_IF_NOTAND
54273 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
54274 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
54275 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
54276 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
54277 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
54278 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
54279 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
54280 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
54281 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
54282 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
54283 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
54284 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
54285 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
54286 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
54287 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
54288 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
54289 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
54290 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
54291 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
54292 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
54293 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
54294 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
54295 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
54296 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
54297 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
54298 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
54299 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
54300     /* This specialized instruction is non-relocatable.
54301        Its 0-th argument, a literal, is the return address where to jump
54302        at the end, back to relocated code. */
54303 
54304 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       277
54305 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-quotient/fR*-no-fast-branches
54306 
54307 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mquotient__fR_A_mno_mfast_mbranches
54308 
54309   /* The residual arity for this instruction does not depend on fast labels. */
54310   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
54311 
54312   /* Define argument-access macros for *primitive-quotient/fR*-no-fast-branches . */
54313 #ifdef JITTER_HAVE_PATCH_IN
54314   /* Define argument-access macros assuming that fast branches are enabled. */
54315     /* The 0th argument is a residual label. */
54316 #if defined(JITTER_DISPATCH_NO_THREADING)
54317 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54318     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54319 #elif defined (JITTER_REPLICATE)
54320 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54321 #else
54322 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54323 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54324 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54325 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54326 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54327 #   define JITTER_ARGF0 JITTER_ARGP0
54328 
54329 #else
54330   /* Define argument-access macros assuming that fast branches are disabled. */
54331     /* The 0th argument is a residual label. */
54332 #if defined(JITTER_DISPATCH_NO_THREADING)
54333 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54334     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54335 #elif defined (JITTER_REPLICATE)
54336 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54337 #else
54338 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54339 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54340 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54341 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54342 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54343 #   define JITTER_ARGF0 JITTER_ARGP0
54344 
54345 # endif // #ifdef JITTER_HAVE_PATCH_IN
54346 
54347 #ifdef JITTER_REPLICATE
54348     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
54349        it on the stack rather than in read-only memory.  I had to do this to prevent
54350        a GCC 8 snapshot on SH from being too clever. */
54351     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54352     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
54353        in memory, as a 16-bit constant; and since it reads it with a PC-relative
54354        load the relocated part crashes.
54355                  mov.w     .L1667,r0
54356                  mov.l     @(r0,r15),r1
54357                  jmp       @r1
54358        r15 is the stack pointer.  The constant at .L1667 is
54359           .L1667:
54360                  .short    232
54361        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
54362        can't work as an immediate.  Shall I keep these code pointers as a single array?
54363        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
54364        but the problem will be the same. */
54365     /* Jump to non-relocatable code. */
54366     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54367 
54368     /* Here the residual arity is given as zero: it's too late to
54369        skip residuals, since we've already jumped and this code is
54370        unreachable.  The instruction pointer, if any, is advanced
54371        in the non-relocatable code. */
54372     JITTER_INSTRUCTION_EPILOG_(*primitive-quotient/fR*-no-fast-branches, _Aprimitive_mquotient__fR_A_mno_mfast_mbranches, 0)
54373 
54374     /* Relocated code will jump to this label in non-relocated code. */
54375   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
54376     JITTER_COMMENT_IN_ASM_("*primitive-quotient/fR*-no-fast-branches non-relocatable code");
54377 #endif // #ifdef JITTER_REPLICATE
54378 #if defined (JITTER_PROFILE_SAMPLE)
54379   JITTER_PROFILE_SAMPLE_UPDATE
54380      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54381       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54382   /* Force the compiler not move sample-profiling instrumentation
54383      beyond this point; this way the actual user code is timed.
54384      This is still not perfect, as residuals are materialised before
54385      we arrive here, but should be adequate at least for slow VM
54386      instructions. */
54387   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
54388 #endif
54389 #if defined (JITTER_PROFILE_COUNT)
54390   /* Notice that, differently from the code above, this
54391      instrumentation code *can* be reordered freely: as long as a
54392      VM instruction is counted, the count increment can be placed
54393      anyehere.  Let GCC move this code and possibly achieve better
54394      throughput by exploiting instruction-level parallelism and
54395      therefore approximate more closely a non-profiled build. */
54396   JITTER_PROFILE_COUNT_UPDATE
54397      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54398       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54399 #endif
54400 
54401 /* User-specified code, instruction-beginning-c part: beginning. */
54402 
54403 
54404 /* User-specified code, instruction-beginning-c part: end */
54405 
54406 
54407     /* User code for *primitive-quotient/fR*-no-fast-branches . */
54408 
54409     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
54410     JITTERLISP_QUOTIENT_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
54411                                      JITTER_UNDER_TOP_MAINSTACK(),
54412                                      JITTER_TOP_MAINSTACK(),
54413                                      JITTER_ARGF0);
54414     JITTER_NIP_MAINSTACK();
54415 
54416     /* End of the user code for *primitive-quotient/fR*-no-fast-branches . */
54417 
54418 /* User-specified code, instruction-end-c part: beginning. */
54419 
54420 
54421 /* User-specified code, instruction-end-c part: end */
54422 
54423 #ifdef JITTER_REPLICATE
54424     /* Advance the instruction pointer, if any, to skip residuals;
54425        then jump back to replicated code. */
54426     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
54427     JITTER_SKIP_RESIDUALS_;
54428     goto * _jitter_back_to_replicated_code_pointer;
54429 #endif // #ifdef JITTER_REPLICATE
54430 
54431     /* Undefine the *primitive-quotient/fR*-no-fast-branches argument macros so they can't be used
54432        by mistake in the instruction body coming next. */
54433 #   undef JITTER_SLOW_REGISTER_OFFSET0
54434 #   undef JITTER_ARG0
54435 #   undef JITTER_ARGN0
54436 #   undef JITTER_ARGU0
54437 #   undef JITTER_ARGP0
54438 #   undef JITTER_ARGF0
54439 
54440 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
54441 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
54442 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
54443 
54444   }
54445 #ifndef JITTER_REPLICATE
54446  JITTER_INSTRUCTION_EPILOG_(*primitive-quotient/fR*-no-fast-branches, _Aprimitive_mquotient__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
54447 #endif // #ifndef JITTER_REPLICATE
54448 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
54449 
54450   JITTER_INSTRUCTION_PROLOG_(*primitive-quotient-unsafe/fR*-no-fast-branches, _Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches, hot)
54451   {
54452     /* This specialized instruction is a replacement. */
54453 #   undef JITTER_BRANCH_FAST
54454 #   define JITTER_BRANCH_FAST JITTER_BRANCH
54455 #   undef JITTER_BRANCH_FAST_IF_ZERO
54456 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
54457 #   undef JITTER_BRANCH_FAST_IF_NONZERO
54458 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
54459 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
54460 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
54461 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
54462 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
54463 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
54464 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
54465 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
54466 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
54467 #   undef JITTER_BRANCH_FAST_IF_EQUAL
54468 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
54469 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
54470 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
54471 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
54472 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
54473 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
54474 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
54475 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
54476 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
54477 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
54478 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
54479 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
54480 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
54481 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
54482 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
54483 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
54484 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
54485 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
54486 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
54487 #   undef JITTER_BRANCH_FAST_IF_AND
54488 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
54489 #   undef JITTER_BRANCH_FAST_IF_NOTAND
54490 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
54491 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
54492 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
54493 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
54494 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
54495 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
54496 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
54497 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
54498 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
54499 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
54500 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
54501 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
54502 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
54503 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
54504 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
54505 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
54506 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
54507 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
54508 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
54509 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
54510 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
54511 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
54512 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
54513 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
54514 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
54515 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
54516 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
54517     /* This specialized instruction is non-relocatable.
54518        Its 0-th argument, a literal, is the return address where to jump
54519        at the end, back to relocated code. */
54520 
54521 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       278
54522 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-quotient-unsafe/fR*-no-fast-branches
54523 
54524 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches
54525 
54526   /* The residual arity for this instruction does not depend on fast labels. */
54527   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
54528 
54529   /* Define argument-access macros for *primitive-quotient-unsafe/fR*-no-fast-branches . */
54530 #ifdef JITTER_HAVE_PATCH_IN
54531   /* Define argument-access macros assuming that fast branches are enabled. */
54532     /* The 0th argument is a residual label. */
54533 #if defined(JITTER_DISPATCH_NO_THREADING)
54534 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54535     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54536 #elif defined (JITTER_REPLICATE)
54537 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54538 #else
54539 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54540 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54541 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54542 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54543 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54544 #   define JITTER_ARGF0 JITTER_ARGP0
54545 
54546 #else
54547   /* Define argument-access macros assuming that fast branches are disabled. */
54548     /* The 0th argument is a residual label. */
54549 #if defined(JITTER_DISPATCH_NO_THREADING)
54550 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54551     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54552 #elif defined (JITTER_REPLICATE)
54553 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54554 #else
54555 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54556 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54557 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54558 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54559 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54560 #   define JITTER_ARGF0 JITTER_ARGP0
54561 
54562 # endif // #ifdef JITTER_HAVE_PATCH_IN
54563 
54564 #ifdef JITTER_REPLICATE
54565     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
54566        it on the stack rather than in read-only memory.  I had to do this to prevent
54567        a GCC 8 snapshot on SH from being too clever. */
54568     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54569     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
54570        in memory, as a 16-bit constant; and since it reads it with a PC-relative
54571        load the relocated part crashes.
54572                  mov.w     .L1667,r0
54573                  mov.l     @(r0,r15),r1
54574                  jmp       @r1
54575        r15 is the stack pointer.  The constant at .L1667 is
54576           .L1667:
54577                  .short    232
54578        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
54579        can't work as an immediate.  Shall I keep these code pointers as a single array?
54580        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
54581        but the problem will be the same. */
54582     /* Jump to non-relocatable code. */
54583     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54584 
54585     /* Here the residual arity is given as zero: it's too late to
54586        skip residuals, since we've already jumped and this code is
54587        unreachable.  The instruction pointer, if any, is advanced
54588        in the non-relocatable code. */
54589     JITTER_INSTRUCTION_EPILOG_(*primitive-quotient-unsafe/fR*-no-fast-branches, _Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches, 0)
54590 
54591     /* Relocated code will jump to this label in non-relocated code. */
54592   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
54593     JITTER_COMMENT_IN_ASM_("*primitive-quotient-unsafe/fR*-no-fast-branches non-relocatable code");
54594 #endif // #ifdef JITTER_REPLICATE
54595 #if defined (JITTER_PROFILE_SAMPLE)
54596   JITTER_PROFILE_SAMPLE_UPDATE
54597      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54598       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54599   /* Force the compiler not move sample-profiling instrumentation
54600      beyond this point; this way the actual user code is timed.
54601      This is still not perfect, as residuals are materialised before
54602      we arrive here, but should be adequate at least for slow VM
54603      instructions. */
54604   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
54605 #endif
54606 #if defined (JITTER_PROFILE_COUNT)
54607   /* Notice that, differently from the code above, this
54608      instrumentation code *can* be reordered freely: as long as a
54609      VM instruction is counted, the count increment can be placed
54610      anyehere.  Let GCC move this code and possibly achieve better
54611      throughput by exploiting instruction-level parallelism and
54612      therefore approximate more closely a non-profiled build. */
54613   JITTER_PROFILE_COUNT_UPDATE
54614      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54615       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54616 #endif
54617 
54618 /* User-specified code, instruction-beginning-c part: beginning. */
54619 
54620 
54621 /* User-specified code, instruction-beginning-c part: end */
54622 
54623 
54624     /* User code for *primitive-quotient-unsafe/fR*-no-fast-branches . */
54625 
54626     /* The second argument has already been validated if we are using this. */
54627     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
54628     JITTERLISP_QUOTIENT_UNSAFE_(JITTER_TOP_MAINSTACK(),
54629                                JITTER_UNDER_TOP_MAINSTACK(),
54630                                JITTER_TOP_MAINSTACK());
54631     JITTER_NIP_MAINSTACK();
54632 
54633     /* End of the user code for *primitive-quotient-unsafe/fR*-no-fast-branches . */
54634 
54635 /* User-specified code, instruction-end-c part: beginning. */
54636 
54637 
54638 /* User-specified code, instruction-end-c part: end */
54639 
54640 #ifdef JITTER_REPLICATE
54641     /* Advance the instruction pointer, if any, to skip residuals;
54642        then jump back to replicated code. */
54643     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
54644     JITTER_SKIP_RESIDUALS_;
54645     goto * _jitter_back_to_replicated_code_pointer;
54646 #endif // #ifdef JITTER_REPLICATE
54647 
54648     /* Undefine the *primitive-quotient-unsafe/fR*-no-fast-branches argument macros so they can't be used
54649        by mistake in the instruction body coming next. */
54650 #   undef JITTER_SLOW_REGISTER_OFFSET0
54651 #   undef JITTER_ARG0
54652 #   undef JITTER_ARGN0
54653 #   undef JITTER_ARGU0
54654 #   undef JITTER_ARGP0
54655 #   undef JITTER_ARGF0
54656 
54657 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
54658 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
54659 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
54660 
54661   }
54662 #ifndef JITTER_REPLICATE
54663  JITTER_INSTRUCTION_EPILOG_(*primitive-quotient-unsafe/fR*-no-fast-branches, _Aprimitive_mquotient_munsafe__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
54664 #endif // #ifndef JITTER_REPLICATE
54665 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
54666 
54667   JITTER_INSTRUCTION_PROLOG_(*primitive-remainder/fR*-no-fast-branches, _Aprimitive_mremainder__fR_A_mno_mfast_mbranches, hot)
54668   {
54669     /* This specialized instruction is a replacement. */
54670 #   undef JITTER_BRANCH_FAST
54671 #   define JITTER_BRANCH_FAST JITTER_BRANCH
54672 #   undef JITTER_BRANCH_FAST_IF_ZERO
54673 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
54674 #   undef JITTER_BRANCH_FAST_IF_NONZERO
54675 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
54676 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
54677 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
54678 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
54679 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
54680 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
54681 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
54682 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
54683 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
54684 #   undef JITTER_BRANCH_FAST_IF_EQUAL
54685 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
54686 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
54687 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
54688 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
54689 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
54690 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
54691 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
54692 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
54693 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
54694 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
54695 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
54696 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
54697 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
54698 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
54699 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
54700 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
54701 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
54702 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
54703 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
54704 #   undef JITTER_BRANCH_FAST_IF_AND
54705 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
54706 #   undef JITTER_BRANCH_FAST_IF_NOTAND
54707 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
54708 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
54709 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
54710 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
54711 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
54712 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
54713 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
54714 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
54715 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
54716 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
54717 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
54718 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
54719 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
54720 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
54721 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
54722 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
54723 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
54724 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
54725 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
54726 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
54727 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
54728 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
54729 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
54730 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
54731 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
54732 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
54733 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
54734     /* This specialized instruction is non-relocatable.
54735        Its 0-th argument, a literal, is the return address where to jump
54736        at the end, back to relocated code. */
54737 
54738 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       279
54739 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-remainder/fR*-no-fast-branches
54740 
54741 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mremainder__fR_A_mno_mfast_mbranches
54742 
54743   /* The residual arity for this instruction does not depend on fast labels. */
54744   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
54745 
54746   /* Define argument-access macros for *primitive-remainder/fR*-no-fast-branches . */
54747 #ifdef JITTER_HAVE_PATCH_IN
54748   /* Define argument-access macros assuming that fast branches are enabled. */
54749     /* The 0th argument is a residual label. */
54750 #if defined(JITTER_DISPATCH_NO_THREADING)
54751 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54752     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54753 #elif defined (JITTER_REPLICATE)
54754 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54755 #else
54756 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54757 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54758 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54759 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54760 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54761 #   define JITTER_ARGF0 JITTER_ARGP0
54762 
54763 #else
54764   /* Define argument-access macros assuming that fast branches are disabled. */
54765     /* The 0th argument is a residual label. */
54766 #if defined(JITTER_DISPATCH_NO_THREADING)
54767 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54768     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54769 #elif defined (JITTER_REPLICATE)
54770 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54771 #else
54772 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54773 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54774 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54775 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54776 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54777 #   define JITTER_ARGF0 JITTER_ARGP0
54778 
54779 # endif // #ifdef JITTER_HAVE_PATCH_IN
54780 
54781 #ifdef JITTER_REPLICATE
54782     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
54783        it on the stack rather than in read-only memory.  I had to do this to prevent
54784        a GCC 8 snapshot on SH from being too clever. */
54785     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54786     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
54787        in memory, as a 16-bit constant; and since it reads it with a PC-relative
54788        load the relocated part crashes.
54789                  mov.w     .L1667,r0
54790                  mov.l     @(r0,r15),r1
54791                  jmp       @r1
54792        r15 is the stack pointer.  The constant at .L1667 is
54793           .L1667:
54794                  .short    232
54795        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
54796        can't work as an immediate.  Shall I keep these code pointers as a single array?
54797        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
54798        but the problem will be the same. */
54799     /* Jump to non-relocatable code. */
54800     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
54801 
54802     /* Here the residual arity is given as zero: it's too late to
54803        skip residuals, since we've already jumped and this code is
54804        unreachable.  The instruction pointer, if any, is advanced
54805        in the non-relocatable code. */
54806     JITTER_INSTRUCTION_EPILOG_(*primitive-remainder/fR*-no-fast-branches, _Aprimitive_mremainder__fR_A_mno_mfast_mbranches, 0)
54807 
54808     /* Relocated code will jump to this label in non-relocated code. */
54809   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
54810     JITTER_COMMENT_IN_ASM_("*primitive-remainder/fR*-no-fast-branches non-relocatable code");
54811 #endif // #ifdef JITTER_REPLICATE
54812 #if defined (JITTER_PROFILE_SAMPLE)
54813   JITTER_PROFILE_SAMPLE_UPDATE
54814      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54815       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54816   /* Force the compiler not move sample-profiling instrumentation
54817      beyond this point; this way the actual user code is timed.
54818      This is still not perfect, as residuals are materialised before
54819      we arrive here, but should be adequate at least for slow VM
54820      instructions. */
54821   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
54822 #endif
54823 #if defined (JITTER_PROFILE_COUNT)
54824   /* Notice that, differently from the code above, this
54825      instrumentation code *can* be reordered freely: as long as a
54826      VM instruction is counted, the count increment can be placed
54827      anyehere.  Let GCC move this code and possibly achieve better
54828      throughput by exploiting instruction-level parallelism and
54829      therefore approximate more closely a non-profiled build. */
54830   JITTER_PROFILE_COUNT_UPDATE
54831      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
54832       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
54833 #endif
54834 
54835 /* User-specified code, instruction-beginning-c part: beginning. */
54836 
54837 
54838 /* User-specified code, instruction-beginning-c part: end */
54839 
54840 
54841     /* User code for *primitive-remainder/fR*-no-fast-branches . */
54842 
54843     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, FIXNUM, JITTER_ARGF0);
54844     JITTERLISP_REMAINDER_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
54845                                       JITTER_UNDER_TOP_MAINSTACK(),
54846                                       JITTER_TOP_MAINSTACK(),
54847                                       JITTER_ARGF0);
54848     JITTER_NIP_MAINSTACK();
54849 
54850     /* End of the user code for *primitive-remainder/fR*-no-fast-branches . */
54851 
54852 /* User-specified code, instruction-end-c part: beginning. */
54853 
54854 
54855 /* User-specified code, instruction-end-c part: end */
54856 
54857 #ifdef JITTER_REPLICATE
54858     /* Advance the instruction pointer, if any, to skip residuals;
54859        then jump back to replicated code. */
54860     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
54861     JITTER_SKIP_RESIDUALS_;
54862     goto * _jitter_back_to_replicated_code_pointer;
54863 #endif // #ifdef JITTER_REPLICATE
54864 
54865     /* Undefine the *primitive-remainder/fR*-no-fast-branches argument macros so they can't be used
54866        by mistake in the instruction body coming next. */
54867 #   undef JITTER_SLOW_REGISTER_OFFSET0
54868 #   undef JITTER_ARG0
54869 #   undef JITTER_ARGN0
54870 #   undef JITTER_ARGU0
54871 #   undef JITTER_ARGP0
54872 #   undef JITTER_ARGF0
54873 
54874 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
54875 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
54876 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
54877 
54878   }
54879 #ifndef JITTER_REPLICATE
54880  JITTER_INSTRUCTION_EPILOG_(*primitive-remainder/fR*-no-fast-branches, _Aprimitive_mremainder__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
54881 #endif // #ifndef JITTER_REPLICATE
54882 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
54883 
54884   JITTER_INSTRUCTION_PROLOG_(*primitive-remainder-unsafe/fR*-no-fast-branches, _Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches, hot)
54885   {
54886     /* This specialized instruction is a replacement. */
54887 #   undef JITTER_BRANCH_FAST
54888 #   define JITTER_BRANCH_FAST JITTER_BRANCH
54889 #   undef JITTER_BRANCH_FAST_IF_ZERO
54890 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
54891 #   undef JITTER_BRANCH_FAST_IF_NONZERO
54892 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
54893 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
54894 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
54895 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
54896 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
54897 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
54898 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
54899 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
54900 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
54901 #   undef JITTER_BRANCH_FAST_IF_EQUAL
54902 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
54903 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
54904 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
54905 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
54906 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
54907 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
54908 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
54909 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
54910 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
54911 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
54912 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
54913 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
54914 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
54915 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
54916 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
54917 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
54918 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
54919 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
54920 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
54921 #   undef JITTER_BRANCH_FAST_IF_AND
54922 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
54923 #   undef JITTER_BRANCH_FAST_IF_NOTAND
54924 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
54925 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
54926 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
54927 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
54928 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
54929 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
54930 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
54931 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
54932 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
54933 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
54934 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
54935 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
54936 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
54937 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
54938 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
54939 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
54940 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
54941 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
54942 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
54943 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
54944 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
54945 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
54946 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
54947 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
54948 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
54949 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
54950 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
54951     /* This specialized instruction is non-relocatable.
54952        Its 0-th argument, a literal, is the return address where to jump
54953        at the end, back to relocated code. */
54954 
54955 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       280
54956 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-remainder-unsafe/fR*-no-fast-branches
54957 
54958 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches
54959 
54960   /* The residual arity for this instruction does not depend on fast labels. */
54961   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
54962 
54963   /* Define argument-access macros for *primitive-remainder-unsafe/fR*-no-fast-branches . */
54964 #ifdef JITTER_HAVE_PATCH_IN
54965   /* Define argument-access macros assuming that fast branches are enabled. */
54966     /* The 0th argument is a residual label. */
54967 #if defined(JITTER_DISPATCH_NO_THREADING)
54968 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54969     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54970 #elif defined (JITTER_REPLICATE)
54971 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54972 #else
54973 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54974 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54975 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54976 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54977 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54978 #   define JITTER_ARGF0 JITTER_ARGP0
54979 
54980 #else
54981   /* Define argument-access macros assuming that fast branches are disabled. */
54982     /* The 0th argument is a residual label. */
54983 #if defined(JITTER_DISPATCH_NO_THREADING)
54984 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
54985     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
54986 #elif defined (JITTER_REPLICATE)
54987 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
54988 #else
54989 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
54990 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
54991 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
54992 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
54993 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
54994 #   define JITTER_ARGF0 JITTER_ARGP0
54995 
54996 # endif // #ifdef JITTER_HAVE_PATCH_IN
54997 
54998 #ifdef JITTER_REPLICATE
54999     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
55000        it on the stack rather than in read-only memory.  I had to do this to prevent
55001        a GCC 8 snapshot on SH from being too clever. */
55002     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55003     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
55004        in memory, as a 16-bit constant; and since it reads it with a PC-relative
55005        load the relocated part crashes.
55006                  mov.w     .L1667,r0
55007                  mov.l     @(r0,r15),r1
55008                  jmp       @r1
55009        r15 is the stack pointer.  The constant at .L1667 is
55010           .L1667:
55011                  .short    232
55012        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
55013        can't work as an immediate.  Shall I keep these code pointers as a single array?
55014        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
55015        but the problem will be the same. */
55016     /* Jump to non-relocatable code. */
55017     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55018 
55019     /* Here the residual arity is given as zero: it's too late to
55020        skip residuals, since we've already jumped and this code is
55021        unreachable.  The instruction pointer, if any, is advanced
55022        in the non-relocatable code. */
55023     JITTER_INSTRUCTION_EPILOG_(*primitive-remainder-unsafe/fR*-no-fast-branches, _Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches, 0)
55024 
55025     /* Relocated code will jump to this label in non-relocated code. */
55026   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
55027     JITTER_COMMENT_IN_ASM_("*primitive-remainder-unsafe/fR*-no-fast-branches non-relocatable code");
55028 #endif // #ifdef JITTER_REPLICATE
55029 #if defined (JITTER_PROFILE_SAMPLE)
55030   JITTER_PROFILE_SAMPLE_UPDATE
55031      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55032       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55033   /* Force the compiler not move sample-profiling instrumentation
55034      beyond this point; this way the actual user code is timed.
55035      This is still not perfect, as residuals are materialised before
55036      we arrive here, but should be adequate at least for slow VM
55037      instructions. */
55038   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
55039 #endif
55040 #if defined (JITTER_PROFILE_COUNT)
55041   /* Notice that, differently from the code above, this
55042      instrumentation code *can* be reordered freely: as long as a
55043      VM instruction is counted, the count increment can be placed
55044      anyehere.  Let GCC move this code and possibly achieve better
55045      throughput by exploiting instruction-level parallelism and
55046      therefore approximate more closely a non-profiled build. */
55047   JITTER_PROFILE_COUNT_UPDATE
55048      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55049       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55050 #endif
55051 
55052 /* User-specified code, instruction-beginning-c part: beginning. */
55053 
55054 
55055 /* User-specified code, instruction-beginning-c part: end */
55056 
55057 
55058     /* User code for *primitive-remainder-unsafe/fR*-no-fast-branches . */
55059 
55060     /* The second argument has already been validated if we are using this. */
55061     JITTERLISPVM_CHECK_TYPES_2(FIXNUM, ANYTHING, JITTER_ARGF0);
55062     JITTERLISP_REMAINDER_UNSAFE_(JITTER_TOP_MAINSTACK(),
55063                                  JITTER_UNDER_TOP_MAINSTACK(),
55064                                  JITTER_TOP_MAINSTACK());
55065     JITTER_NIP_MAINSTACK();
55066 
55067     /* End of the user code for *primitive-remainder-unsafe/fR*-no-fast-branches . */
55068 
55069 /* User-specified code, instruction-end-c part: beginning. */
55070 
55071 
55072 /* User-specified code, instruction-end-c part: end */
55073 
55074 #ifdef JITTER_REPLICATE
55075     /* Advance the instruction pointer, if any, to skip residuals;
55076        then jump back to replicated code. */
55077     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
55078     JITTER_SKIP_RESIDUALS_;
55079     goto * _jitter_back_to_replicated_code_pointer;
55080 #endif // #ifdef JITTER_REPLICATE
55081 
55082     /* Undefine the *primitive-remainder-unsafe/fR*-no-fast-branches argument macros so they can't be used
55083        by mistake in the instruction body coming next. */
55084 #   undef JITTER_SLOW_REGISTER_OFFSET0
55085 #   undef JITTER_ARG0
55086 #   undef JITTER_ARGN0
55087 #   undef JITTER_ARGU0
55088 #   undef JITTER_ARGP0
55089 #   undef JITTER_ARGF0
55090 
55091 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
55092 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
55093 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
55094 
55095   }
55096 #ifndef JITTER_REPLICATE
55097  JITTER_INSTRUCTION_EPILOG_(*primitive-remainder-unsafe/fR*-no-fast-branches, _Aprimitive_mremainder_munsafe__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
55098 #endif // #ifndef JITTER_REPLICATE
55099 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
55100 
55101   JITTER_INSTRUCTION_PROLOG_(*primitive-set-carb-special/fR*-no-fast-branches, _Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches, hot)
55102   {
55103     /* This specialized instruction is a replacement. */
55104 #   undef JITTER_BRANCH_FAST
55105 #   define JITTER_BRANCH_FAST JITTER_BRANCH
55106 #   undef JITTER_BRANCH_FAST_IF_ZERO
55107 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
55108 #   undef JITTER_BRANCH_FAST_IF_NONZERO
55109 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
55110 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
55111 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
55112 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
55113 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
55114 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
55115 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
55116 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
55117 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
55118 #   undef JITTER_BRANCH_FAST_IF_EQUAL
55119 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
55120 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
55121 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
55122 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
55123 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
55124 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
55125 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
55126 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
55127 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
55128 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
55129 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
55130 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
55131 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
55132 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
55133 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
55134 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
55135 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
55136 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
55137 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
55138 #   undef JITTER_BRANCH_FAST_IF_AND
55139 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
55140 #   undef JITTER_BRANCH_FAST_IF_NOTAND
55141 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
55142 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
55143 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
55144 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
55145 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
55146 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
55147 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
55148 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
55149 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
55150 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
55151 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
55152 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
55153 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
55154 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
55155 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
55156 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
55157 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
55158 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
55159 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
55160 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
55161 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
55162 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
55163 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
55164 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
55165 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
55166 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
55167 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
55168     /* This specialized instruction is non-relocatable.
55169        Its 0-th argument, a literal, is the return address where to jump
55170        at the end, back to relocated code. */
55171 
55172 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       281
55173 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-set-carb-special/fR*-no-fast-branches
55174 
55175 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches
55176 
55177   /* The residual arity for this instruction does not depend on fast labels. */
55178   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
55179 
55180   /* Define argument-access macros for *primitive-set-carb-special/fR*-no-fast-branches . */
55181 #ifdef JITTER_HAVE_PATCH_IN
55182   /* Define argument-access macros assuming that fast branches are enabled. */
55183     /* The 0th argument is a residual label. */
55184 #if defined(JITTER_DISPATCH_NO_THREADING)
55185 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55186     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55187 #elif defined (JITTER_REPLICATE)
55188 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55189 #else
55190 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55191 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55192 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55193 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55194 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55195 #   define JITTER_ARGF0 JITTER_ARGP0
55196 
55197 #else
55198   /* Define argument-access macros assuming that fast branches are disabled. */
55199     /* The 0th argument is a residual label. */
55200 #if defined(JITTER_DISPATCH_NO_THREADING)
55201 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55202     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55203 #elif defined (JITTER_REPLICATE)
55204 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55205 #else
55206 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55207 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55208 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55209 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55210 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55211 #   define JITTER_ARGF0 JITTER_ARGP0
55212 
55213 # endif // #ifdef JITTER_HAVE_PATCH_IN
55214 
55215 #ifdef JITTER_REPLICATE
55216     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
55217        it on the stack rather than in read-only memory.  I had to do this to prevent
55218        a GCC 8 snapshot on SH from being too clever. */
55219     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55220     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
55221        in memory, as a 16-bit constant; and since it reads it with a PC-relative
55222        load the relocated part crashes.
55223                  mov.w     .L1667,r0
55224                  mov.l     @(r0,r15),r1
55225                  jmp       @r1
55226        r15 is the stack pointer.  The constant at .L1667 is
55227           .L1667:
55228                  .short    232
55229        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
55230        can't work as an immediate.  Shall I keep these code pointers as a single array?
55231        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
55232        but the problem will be the same. */
55233     /* Jump to non-relocatable code. */
55234     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55235 
55236     /* Here the residual arity is given as zero: it's too late to
55237        skip residuals, since we've already jumped and this code is
55238        unreachable.  The instruction pointer, if any, is advanced
55239        in the non-relocatable code. */
55240     JITTER_INSTRUCTION_EPILOG_(*primitive-set-carb-special/fR*-no-fast-branches, _Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches, 0)
55241 
55242     /* Relocated code will jump to this label in non-relocated code. */
55243   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
55244     JITTER_COMMENT_IN_ASM_("*primitive-set-carb-special/fR*-no-fast-branches non-relocatable code");
55245 #endif // #ifdef JITTER_REPLICATE
55246 #if defined (JITTER_PROFILE_SAMPLE)
55247   JITTER_PROFILE_SAMPLE_UPDATE
55248      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55249       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55250   /* Force the compiler not move sample-profiling instrumentation
55251      beyond this point; this way the actual user code is timed.
55252      This is still not perfect, as residuals are materialised before
55253      we arrive here, but should be adequate at least for slow VM
55254      instructions. */
55255   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
55256 #endif
55257 #if defined (JITTER_PROFILE_COUNT)
55258   /* Notice that, differently from the code above, this
55259      instrumentation code *can* be reordered freely: as long as a
55260      VM instruction is counted, the count increment can be placed
55261      anyehere.  Let GCC move this code and possibly achieve better
55262      throughput by exploiting instruction-level parallelism and
55263      therefore approximate more closely a non-profiled build. */
55264   JITTER_PROFILE_COUNT_UPDATE
55265      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55266       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55267 #endif
55268 
55269 /* User-specified code, instruction-beginning-c part: beginning. */
55270 
55271 
55272 /* User-specified code, instruction-beginning-c part: end */
55273 
55274 
55275     /* User code for *primitive-set-carb-special/fR*-no-fast-branches . */
55276 
55277     JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
55278     jitterlisp_object useless __attribute__ ((unused));
55279     JITTERLISP_SET_CARB_(useless,
55280                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
55281     /* Leave the two operands on the stack. */
55282 
55283     /* End of the user code for *primitive-set-carb-special/fR*-no-fast-branches . */
55284 
55285 /* User-specified code, instruction-end-c part: beginning. */
55286 
55287 
55288 /* User-specified code, instruction-end-c part: end */
55289 
55290 #ifdef JITTER_REPLICATE
55291     /* Advance the instruction pointer, if any, to skip residuals;
55292        then jump back to replicated code. */
55293     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
55294     JITTER_SKIP_RESIDUALS_;
55295     goto * _jitter_back_to_replicated_code_pointer;
55296 #endif // #ifdef JITTER_REPLICATE
55297 
55298     /* Undefine the *primitive-set-carb-special/fR*-no-fast-branches argument macros so they can't be used
55299        by mistake in the instruction body coming next. */
55300 #   undef JITTER_SLOW_REGISTER_OFFSET0
55301 #   undef JITTER_ARG0
55302 #   undef JITTER_ARGN0
55303 #   undef JITTER_ARGU0
55304 #   undef JITTER_ARGP0
55305 #   undef JITTER_ARGF0
55306 
55307 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
55308 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
55309 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
55310 
55311   }
55312 #ifndef JITTER_REPLICATE
55313  JITTER_INSTRUCTION_EPILOG_(*primitive-set-carb-special/fR*-no-fast-branches, _Aprimitive_mset_mcarb_mspecial__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
55314 #endif // #ifndef JITTER_REPLICATE
55315 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
55316 
55317   JITTER_INSTRUCTION_PROLOG_(*primitive-set-cdrb-special/fR*-no-fast-branches, _Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches, hot)
55318   {
55319     /* This specialized instruction is a replacement. */
55320 #   undef JITTER_BRANCH_FAST
55321 #   define JITTER_BRANCH_FAST JITTER_BRANCH
55322 #   undef JITTER_BRANCH_FAST_IF_ZERO
55323 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
55324 #   undef JITTER_BRANCH_FAST_IF_NONZERO
55325 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
55326 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
55327 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
55328 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
55329 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
55330 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
55331 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
55332 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
55333 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
55334 #   undef JITTER_BRANCH_FAST_IF_EQUAL
55335 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
55336 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
55337 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
55338 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
55339 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
55340 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
55341 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
55342 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
55343 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
55344 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
55345 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
55346 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
55347 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
55348 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
55349 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
55350 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
55351 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
55352 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
55353 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
55354 #   undef JITTER_BRANCH_FAST_IF_AND
55355 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
55356 #   undef JITTER_BRANCH_FAST_IF_NOTAND
55357 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
55358 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
55359 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
55360 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
55361 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
55362 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
55363 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
55364 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
55365 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
55366 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
55367 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
55368 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
55369 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
55370 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
55371 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
55372 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
55373 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
55374 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
55375 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
55376 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
55377 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
55378 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
55379 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
55380 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
55381 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
55382 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
55383 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
55384     /* This specialized instruction is non-relocatable.
55385        Its 0-th argument, a literal, is the return address where to jump
55386        at the end, back to relocated code. */
55387 
55388 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       282
55389 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-set-cdrb-special/fR*-no-fast-branches
55390 
55391 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches
55392 
55393   /* The residual arity for this instruction does not depend on fast labels. */
55394   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
55395 
55396   /* Define argument-access macros for *primitive-set-cdrb-special/fR*-no-fast-branches . */
55397 #ifdef JITTER_HAVE_PATCH_IN
55398   /* Define argument-access macros assuming that fast branches are enabled. */
55399     /* The 0th argument is a residual label. */
55400 #if defined(JITTER_DISPATCH_NO_THREADING)
55401 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55402     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55403 #elif defined (JITTER_REPLICATE)
55404 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55405 #else
55406 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55407 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55408 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55409 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55410 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55411 #   define JITTER_ARGF0 JITTER_ARGP0
55412 
55413 #else
55414   /* Define argument-access macros assuming that fast branches are disabled. */
55415     /* The 0th argument is a residual label. */
55416 #if defined(JITTER_DISPATCH_NO_THREADING)
55417 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55418     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55419 #elif defined (JITTER_REPLICATE)
55420 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55421 #else
55422 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55423 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55424 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55425 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55426 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55427 #   define JITTER_ARGF0 JITTER_ARGP0
55428 
55429 # endif // #ifdef JITTER_HAVE_PATCH_IN
55430 
55431 #ifdef JITTER_REPLICATE
55432     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
55433        it on the stack rather than in read-only memory.  I had to do this to prevent
55434        a GCC 8 snapshot on SH from being too clever. */
55435     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55436     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
55437        in memory, as a 16-bit constant; and since it reads it with a PC-relative
55438        load the relocated part crashes.
55439                  mov.w     .L1667,r0
55440                  mov.l     @(r0,r15),r1
55441                  jmp       @r1
55442        r15 is the stack pointer.  The constant at .L1667 is
55443           .L1667:
55444                  .short    232
55445        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
55446        can't work as an immediate.  Shall I keep these code pointers as a single array?
55447        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
55448        but the problem will be the same. */
55449     /* Jump to non-relocatable code. */
55450     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55451 
55452     /* Here the residual arity is given as zero: it's too late to
55453        skip residuals, since we've already jumped and this code is
55454        unreachable.  The instruction pointer, if any, is advanced
55455        in the non-relocatable code. */
55456     JITTER_INSTRUCTION_EPILOG_(*primitive-set-cdrb-special/fR*-no-fast-branches, _Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches, 0)
55457 
55458     /* Relocated code will jump to this label in non-relocated code. */
55459   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
55460     JITTER_COMMENT_IN_ASM_("*primitive-set-cdrb-special/fR*-no-fast-branches non-relocatable code");
55461 #endif // #ifdef JITTER_REPLICATE
55462 #if defined (JITTER_PROFILE_SAMPLE)
55463   JITTER_PROFILE_SAMPLE_UPDATE
55464      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55465       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55466   /* Force the compiler not move sample-profiling instrumentation
55467      beyond this point; this way the actual user code is timed.
55468      This is still not perfect, as residuals are materialised before
55469      we arrive here, but should be adequate at least for slow VM
55470      instructions. */
55471   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
55472 #endif
55473 #if defined (JITTER_PROFILE_COUNT)
55474   /* Notice that, differently from the code above, this
55475      instrumentation code *can* be reordered freely: as long as a
55476      VM instruction is counted, the count increment can be placed
55477      anyehere.  Let GCC move this code and possibly achieve better
55478      throughput by exploiting instruction-level parallelism and
55479      therefore approximate more closely a non-profiled build. */
55480   JITTER_PROFILE_COUNT_UPDATE
55481      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55482       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55483 #endif
55484 
55485 /* User-specified code, instruction-beginning-c part: beginning. */
55486 
55487 
55488 /* User-specified code, instruction-beginning-c part: end */
55489 
55490 
55491     /* User code for *primitive-set-cdrb-special/fR*-no-fast-branches . */
55492 
55493     JITTERLISPVM_CHECK_TYPES_2(CONS, ANYTHING, JITTER_ARGF0);
55494     jitterlisp_object useless __attribute__ ((unused));
55495     JITTERLISP_SET_CDRB_(useless,
55496                          JITTER_UNDER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
55497     /* Leave the two operands on the stack. */
55498 
55499     /* End of the user code for *primitive-set-cdrb-special/fR*-no-fast-branches . */
55500 
55501 /* User-specified code, instruction-end-c part: beginning. */
55502 
55503 
55504 /* User-specified code, instruction-end-c part: end */
55505 
55506 #ifdef JITTER_REPLICATE
55507     /* Advance the instruction pointer, if any, to skip residuals;
55508        then jump back to replicated code. */
55509     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
55510     JITTER_SKIP_RESIDUALS_;
55511     goto * _jitter_back_to_replicated_code_pointer;
55512 #endif // #ifdef JITTER_REPLICATE
55513 
55514     /* Undefine the *primitive-set-cdrb-special/fR*-no-fast-branches argument macros so they can't be used
55515        by mistake in the instruction body coming next. */
55516 #   undef JITTER_SLOW_REGISTER_OFFSET0
55517 #   undef JITTER_ARG0
55518 #   undef JITTER_ARGN0
55519 #   undef JITTER_ARGU0
55520 #   undef JITTER_ARGP0
55521 #   undef JITTER_ARGF0
55522 
55523 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
55524 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
55525 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
55526 
55527   }
55528 #ifndef JITTER_REPLICATE
55529  JITTER_INSTRUCTION_EPILOG_(*primitive-set-cdrb-special/fR*-no-fast-branches, _Aprimitive_mset_mcdrb_mspecial__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
55530 #endif // #ifndef JITTER_REPLICATE
55531 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
55532 
55533   JITTER_INSTRUCTION_PROLOG_(*primitive-two-divided/fR*-no-fast-branches, _Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches, hot)
55534   {
55535     /* This specialized instruction is a replacement. */
55536 #   undef JITTER_BRANCH_FAST
55537 #   define JITTER_BRANCH_FAST JITTER_BRANCH
55538 #   undef JITTER_BRANCH_FAST_IF_ZERO
55539 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
55540 #   undef JITTER_BRANCH_FAST_IF_NONZERO
55541 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
55542 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
55543 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
55544 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
55545 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
55546 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
55547 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
55548 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
55549 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
55550 #   undef JITTER_BRANCH_FAST_IF_EQUAL
55551 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
55552 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
55553 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
55554 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
55555 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
55556 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
55557 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
55558 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
55559 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
55560 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
55561 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
55562 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
55563 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
55564 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
55565 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
55566 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
55567 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
55568 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
55569 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
55570 #   undef JITTER_BRANCH_FAST_IF_AND
55571 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
55572 #   undef JITTER_BRANCH_FAST_IF_NOTAND
55573 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
55574 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
55575 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
55576 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
55577 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
55578 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
55579 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
55580 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
55581 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
55582 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
55583 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
55584 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
55585 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
55586 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
55587 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
55588 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
55589 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
55590 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
55591 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
55592 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
55593 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
55594 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
55595 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
55596 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
55597 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
55598 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
55599 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
55600     /* This specialized instruction is non-relocatable.
55601        Its 0-th argument, a literal, is the return address where to jump
55602        at the end, back to relocated code. */
55603 
55604 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       283
55605 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-two-divided/fR*-no-fast-branches
55606 
55607 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches
55608 
55609   /* The residual arity for this instruction does not depend on fast labels. */
55610   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
55611 
55612   /* Define argument-access macros for *primitive-two-divided/fR*-no-fast-branches . */
55613 #ifdef JITTER_HAVE_PATCH_IN
55614   /* Define argument-access macros assuming that fast branches are enabled. */
55615     /* The 0th argument is a residual label. */
55616 #if defined(JITTER_DISPATCH_NO_THREADING)
55617 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55618     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55619 #elif defined (JITTER_REPLICATE)
55620 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55621 #else
55622 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55623 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55624 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55625 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55626 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55627 #   define JITTER_ARGF0 JITTER_ARGP0
55628 
55629 #else
55630   /* Define argument-access macros assuming that fast branches are disabled. */
55631     /* The 0th argument is a residual label. */
55632 #if defined(JITTER_DISPATCH_NO_THREADING)
55633 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55634     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55635 #elif defined (JITTER_REPLICATE)
55636 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55637 #else
55638 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55639 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55640 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55641 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55642 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55643 #   define JITTER_ARGF0 JITTER_ARGP0
55644 
55645 # endif // #ifdef JITTER_HAVE_PATCH_IN
55646 
55647 #ifdef JITTER_REPLICATE
55648     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
55649        it on the stack rather than in read-only memory.  I had to do this to prevent
55650        a GCC 8 snapshot on SH from being too clever. */
55651     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55652     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
55653        in memory, as a 16-bit constant; and since it reads it with a PC-relative
55654        load the relocated part crashes.
55655                  mov.w     .L1667,r0
55656                  mov.l     @(r0,r15),r1
55657                  jmp       @r1
55658        r15 is the stack pointer.  The constant at .L1667 is
55659           .L1667:
55660                  .short    232
55661        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
55662        can't work as an immediate.  Shall I keep these code pointers as a single array?
55663        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
55664        but the problem will be the same. */
55665     /* Jump to non-relocatable code. */
55666     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55667 
55668     /* Here the residual arity is given as zero: it's too late to
55669        skip residuals, since we've already jumped and this code is
55670        unreachable.  The instruction pointer, if any, is advanced
55671        in the non-relocatable code. */
55672     JITTER_INSTRUCTION_EPILOG_(*primitive-two-divided/fR*-no-fast-branches, _Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches, 0)
55673 
55674     /* Relocated code will jump to this label in non-relocated code. */
55675   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
55676     JITTER_COMMENT_IN_ASM_("*primitive-two-divided/fR*-no-fast-branches non-relocatable code");
55677 #endif // #ifdef JITTER_REPLICATE
55678 #if defined (JITTER_PROFILE_SAMPLE)
55679   JITTER_PROFILE_SAMPLE_UPDATE
55680      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55681       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55682   /* Force the compiler not move sample-profiling instrumentation
55683      beyond this point; this way the actual user code is timed.
55684      This is still not perfect, as residuals are materialised before
55685      we arrive here, but should be adequate at least for slow VM
55686      instructions. */
55687   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
55688 #endif
55689 #if defined (JITTER_PROFILE_COUNT)
55690   /* Notice that, differently from the code above, this
55691      instrumentation code *can* be reordered freely: as long as a
55692      VM instruction is counted, the count increment can be placed
55693      anyehere.  Let GCC move this code and possibly achieve better
55694      throughput by exploiting instruction-level parallelism and
55695      therefore approximate more closely a non-profiled build. */
55696   JITTER_PROFILE_COUNT_UPDATE
55697      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55698       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55699 #endif
55700 
55701 /* User-specified code, instruction-beginning-c part: beginning. */
55702 
55703 
55704 /* User-specified code, instruction-beginning-c part: end */
55705 
55706 
55707     /* User code for *primitive-two-divided/fR*-no-fast-branches . */
55708 
55709     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
55710     JITTERLISP_2DIVIDED_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
55711 
55712     /* End of the user code for *primitive-two-divided/fR*-no-fast-branches . */
55713 
55714 /* User-specified code, instruction-end-c part: beginning. */
55715 
55716 
55717 /* User-specified code, instruction-end-c part: end */
55718 
55719 #ifdef JITTER_REPLICATE
55720     /* Advance the instruction pointer, if any, to skip residuals;
55721        then jump back to replicated code. */
55722     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
55723     JITTER_SKIP_RESIDUALS_;
55724     goto * _jitter_back_to_replicated_code_pointer;
55725 #endif // #ifdef JITTER_REPLICATE
55726 
55727     /* Undefine the *primitive-two-divided/fR*-no-fast-branches argument macros so they can't be used
55728        by mistake in the instruction body coming next. */
55729 #   undef JITTER_SLOW_REGISTER_OFFSET0
55730 #   undef JITTER_ARG0
55731 #   undef JITTER_ARGN0
55732 #   undef JITTER_ARGU0
55733 #   undef JITTER_ARGP0
55734 #   undef JITTER_ARGF0
55735 
55736 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
55737 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
55738 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
55739 
55740   }
55741 #ifndef JITTER_REPLICATE
55742  JITTER_INSTRUCTION_EPILOG_(*primitive-two-divided/fR*-no-fast-branches, _Aprimitive_mtwo_mdivided__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
55743 #endif // #ifndef JITTER_REPLICATE
55744 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
55745 
55746   JITTER_INSTRUCTION_PROLOG_(*primitive-two-quotient/fR*-no-fast-branches, _Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches, hot)
55747   {
55748     /* This specialized instruction is a replacement. */
55749 #   undef JITTER_BRANCH_FAST
55750 #   define JITTER_BRANCH_FAST JITTER_BRANCH
55751 #   undef JITTER_BRANCH_FAST_IF_ZERO
55752 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
55753 #   undef JITTER_BRANCH_FAST_IF_NONZERO
55754 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
55755 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
55756 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
55757 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
55758 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
55759 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
55760 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
55761 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
55762 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
55763 #   undef JITTER_BRANCH_FAST_IF_EQUAL
55764 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
55765 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
55766 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
55767 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
55768 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
55769 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
55770 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
55771 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
55772 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
55773 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
55774 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
55775 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
55776 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
55777 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
55778 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
55779 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
55780 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
55781 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
55782 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
55783 #   undef JITTER_BRANCH_FAST_IF_AND
55784 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
55785 #   undef JITTER_BRANCH_FAST_IF_NOTAND
55786 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
55787 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
55788 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
55789 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
55790 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
55791 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
55792 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
55793 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
55794 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
55795 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
55796 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
55797 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
55798 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
55799 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
55800 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
55801 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
55802 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
55803 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
55804 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
55805 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
55806 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
55807 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
55808 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
55809 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
55810 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
55811 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
55812 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
55813     /* This specialized instruction is non-relocatable.
55814        Its 0-th argument, a literal, is the return address where to jump
55815        at the end, back to relocated code. */
55816 
55817 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       284
55818 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-two-quotient/fR*-no-fast-branches
55819 
55820 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches
55821 
55822   /* The residual arity for this instruction does not depend on fast labels. */
55823   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
55824 
55825   /* Define argument-access macros for *primitive-two-quotient/fR*-no-fast-branches . */
55826 #ifdef JITTER_HAVE_PATCH_IN
55827   /* Define argument-access macros assuming that fast branches are enabled. */
55828     /* The 0th argument is a residual label. */
55829 #if defined(JITTER_DISPATCH_NO_THREADING)
55830 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55831     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55832 #elif defined (JITTER_REPLICATE)
55833 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55834 #else
55835 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55836 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55837 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55838 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55839 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55840 #   define JITTER_ARGF0 JITTER_ARGP0
55841 
55842 #else
55843   /* Define argument-access macros assuming that fast branches are disabled. */
55844     /* The 0th argument is a residual label. */
55845 #if defined(JITTER_DISPATCH_NO_THREADING)
55846 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
55847     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
55848 #elif defined (JITTER_REPLICATE)
55849 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
55850 #else
55851 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
55852 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
55853 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
55854 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
55855 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
55856 #   define JITTER_ARGF0 JITTER_ARGP0
55857 
55858 # endif // #ifdef JITTER_HAVE_PATCH_IN
55859 
55860 #ifdef JITTER_REPLICATE
55861     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
55862        it on the stack rather than in read-only memory.  I had to do this to prevent
55863        a GCC 8 snapshot on SH from being too clever. */
55864     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55865     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
55866        in memory, as a 16-bit constant; and since it reads it with a PC-relative
55867        load the relocated part crashes.
55868                  mov.w     .L1667,r0
55869                  mov.l     @(r0,r15),r1
55870                  jmp       @r1
55871        r15 is the stack pointer.  The constant at .L1667 is
55872           .L1667:
55873                  .short    232
55874        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
55875        can't work as an immediate.  Shall I keep these code pointers as a single array?
55876        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
55877        but the problem will be the same. */
55878     /* Jump to non-relocatable code. */
55879     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
55880 
55881     /* Here the residual arity is given as zero: it's too late to
55882        skip residuals, since we've already jumped and this code is
55883        unreachable.  The instruction pointer, if any, is advanced
55884        in the non-relocatable code. */
55885     JITTER_INSTRUCTION_EPILOG_(*primitive-two-quotient/fR*-no-fast-branches, _Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches, 0)
55886 
55887     /* Relocated code will jump to this label in non-relocated code. */
55888   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
55889     JITTER_COMMENT_IN_ASM_("*primitive-two-quotient/fR*-no-fast-branches non-relocatable code");
55890 #endif // #ifdef JITTER_REPLICATE
55891 #if defined (JITTER_PROFILE_SAMPLE)
55892   JITTER_PROFILE_SAMPLE_UPDATE
55893      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55894       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55895   /* Force the compiler not move sample-profiling instrumentation
55896      beyond this point; this way the actual user code is timed.
55897      This is still not perfect, as residuals are materialised before
55898      we arrive here, but should be adequate at least for slow VM
55899      instructions. */
55900   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
55901 #endif
55902 #if defined (JITTER_PROFILE_COUNT)
55903   /* Notice that, differently from the code above, this
55904      instrumentation code *can* be reordered freely: as long as a
55905      VM instruction is counted, the count increment can be placed
55906      anyehere.  Let GCC move this code and possibly achieve better
55907      throughput by exploiting instruction-level parallelism and
55908      therefore approximate more closely a non-profiled build. */
55909   JITTER_PROFILE_COUNT_UPDATE
55910      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
55911       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
55912 #endif
55913 
55914 /* User-specified code, instruction-beginning-c part: beginning. */
55915 
55916 
55917 /* User-specified code, instruction-beginning-c part: end */
55918 
55919 
55920     /* User code for *primitive-two-quotient/fR*-no-fast-branches . */
55921 
55922     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
55923     JITTERLISP_2QUOTIENT_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
55924 
55925     /* End of the user code for *primitive-two-quotient/fR*-no-fast-branches . */
55926 
55927 /* User-specified code, instruction-end-c part: beginning. */
55928 
55929 
55930 /* User-specified code, instruction-end-c part: end */
55931 
55932 #ifdef JITTER_REPLICATE
55933     /* Advance the instruction pointer, if any, to skip residuals;
55934        then jump back to replicated code. */
55935     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
55936     JITTER_SKIP_RESIDUALS_;
55937     goto * _jitter_back_to_replicated_code_pointer;
55938 #endif // #ifdef JITTER_REPLICATE
55939 
55940     /* Undefine the *primitive-two-quotient/fR*-no-fast-branches argument macros so they can't be used
55941        by mistake in the instruction body coming next. */
55942 #   undef JITTER_SLOW_REGISTER_OFFSET0
55943 #   undef JITTER_ARG0
55944 #   undef JITTER_ARGN0
55945 #   undef JITTER_ARGU0
55946 #   undef JITTER_ARGP0
55947 #   undef JITTER_ARGF0
55948 
55949 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
55950 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
55951 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
55952 
55953   }
55954 #ifndef JITTER_REPLICATE
55955  JITTER_INSTRUCTION_EPILOG_(*primitive-two-quotient/fR*-no-fast-branches, _Aprimitive_mtwo_mquotient__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
55956 #endif // #ifndef JITTER_REPLICATE
55957 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
55958 
55959   JITTER_INSTRUCTION_PROLOG_(*primitive-two-remainder/fR*-no-fast-branches, _Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches, hot)
55960   {
55961     /* This specialized instruction is a replacement. */
55962 #   undef JITTER_BRANCH_FAST
55963 #   define JITTER_BRANCH_FAST JITTER_BRANCH
55964 #   undef JITTER_BRANCH_FAST_IF_ZERO
55965 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
55966 #   undef JITTER_BRANCH_FAST_IF_NONZERO
55967 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
55968 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
55969 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
55970 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
55971 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
55972 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
55973 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
55974 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
55975 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
55976 #   undef JITTER_BRANCH_FAST_IF_EQUAL
55977 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
55978 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
55979 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
55980 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
55981 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
55982 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
55983 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
55984 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
55985 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
55986 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
55987 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
55988 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
55989 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
55990 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
55991 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
55992 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
55993 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
55994 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
55995 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
55996 #   undef JITTER_BRANCH_FAST_IF_AND
55997 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
55998 #   undef JITTER_BRANCH_FAST_IF_NOTAND
55999 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
56000 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
56001 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
56002 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
56003 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
56004 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
56005 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
56006 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
56007 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
56008 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
56009 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
56010 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
56011 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
56012 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
56013 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
56014 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
56015 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
56016 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
56017 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
56018 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
56019 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
56020 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
56021 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
56022 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
56023 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
56024 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
56025 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
56026     /* This specialized instruction is non-relocatable.
56027        Its 0-th argument, a literal, is the return address where to jump
56028        at the end, back to relocated code. */
56029 
56030 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       285
56031 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-two-remainder/fR*-no-fast-branches
56032 
56033 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches
56034 
56035   /* The residual arity for this instruction does not depend on fast labels. */
56036   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
56037 
56038   /* Define argument-access macros for *primitive-two-remainder/fR*-no-fast-branches . */
56039 #ifdef JITTER_HAVE_PATCH_IN
56040   /* Define argument-access macros assuming that fast branches are enabled. */
56041     /* The 0th argument is a residual label. */
56042 #if defined(JITTER_DISPATCH_NO_THREADING)
56043 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56044     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56045 #elif defined (JITTER_REPLICATE)
56046 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56047 #else
56048 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56049 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56050 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56051 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56052 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56053 #   define JITTER_ARGF0 JITTER_ARGP0
56054 
56055 #else
56056   /* Define argument-access macros assuming that fast branches are disabled. */
56057     /* The 0th argument is a residual label. */
56058 #if defined(JITTER_DISPATCH_NO_THREADING)
56059 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56060     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56061 #elif defined (JITTER_REPLICATE)
56062 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56063 #else
56064 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56065 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56066 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56067 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56068 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56069 #   define JITTER_ARGF0 JITTER_ARGP0
56070 
56071 # endif // #ifdef JITTER_HAVE_PATCH_IN
56072 
56073 #ifdef JITTER_REPLICATE
56074     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
56075        it on the stack rather than in read-only memory.  I had to do this to prevent
56076        a GCC 8 snapshot on SH from being too clever. */
56077     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56078     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
56079        in memory, as a 16-bit constant; and since it reads it with a PC-relative
56080        load the relocated part crashes.
56081                  mov.w     .L1667,r0
56082                  mov.l     @(r0,r15),r1
56083                  jmp       @r1
56084        r15 is the stack pointer.  The constant at .L1667 is
56085           .L1667:
56086                  .short    232
56087        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
56088        can't work as an immediate.  Shall I keep these code pointers as a single array?
56089        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
56090        but the problem will be the same. */
56091     /* Jump to non-relocatable code. */
56092     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56093 
56094     /* Here the residual arity is given as zero: it's too late to
56095        skip residuals, since we've already jumped and this code is
56096        unreachable.  The instruction pointer, if any, is advanced
56097        in the non-relocatable code. */
56098     JITTER_INSTRUCTION_EPILOG_(*primitive-two-remainder/fR*-no-fast-branches, _Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches, 0)
56099 
56100     /* Relocated code will jump to this label in non-relocated code. */
56101   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
56102     JITTER_COMMENT_IN_ASM_("*primitive-two-remainder/fR*-no-fast-branches non-relocatable code");
56103 #endif // #ifdef JITTER_REPLICATE
56104 #if defined (JITTER_PROFILE_SAMPLE)
56105   JITTER_PROFILE_SAMPLE_UPDATE
56106      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56107       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56108   /* Force the compiler not move sample-profiling instrumentation
56109      beyond this point; this way the actual user code is timed.
56110      This is still not perfect, as residuals are materialised before
56111      we arrive here, but should be adequate at least for slow VM
56112      instructions. */
56113   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
56114 #endif
56115 #if defined (JITTER_PROFILE_COUNT)
56116   /* Notice that, differently from the code above, this
56117      instrumentation code *can* be reordered freely: as long as a
56118      VM instruction is counted, the count increment can be placed
56119      anyehere.  Let GCC move this code and possibly achieve better
56120      throughput by exploiting instruction-level parallelism and
56121      therefore approximate more closely a non-profiled build. */
56122   JITTER_PROFILE_COUNT_UPDATE
56123      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56124       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56125 #endif
56126 
56127 /* User-specified code, instruction-beginning-c part: beginning. */
56128 
56129 
56130 /* User-specified code, instruction-beginning-c part: end */
56131 
56132 
56133     /* User code for *primitive-two-remainder/fR*-no-fast-branches . */
56134 
56135     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
56136     JITTERLISP_2REMAINDER_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
56137 
56138     /* End of the user code for *primitive-two-remainder/fR*-no-fast-branches . */
56139 
56140 /* User-specified code, instruction-end-c part: beginning. */
56141 
56142 
56143 /* User-specified code, instruction-end-c part: end */
56144 
56145 #ifdef JITTER_REPLICATE
56146     /* Advance the instruction pointer, if any, to skip residuals;
56147        then jump back to replicated code. */
56148     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
56149     JITTER_SKIP_RESIDUALS_;
56150     goto * _jitter_back_to_replicated_code_pointer;
56151 #endif // #ifdef JITTER_REPLICATE
56152 
56153     /* Undefine the *primitive-two-remainder/fR*-no-fast-branches argument macros so they can't be used
56154        by mistake in the instruction body coming next. */
56155 #   undef JITTER_SLOW_REGISTER_OFFSET0
56156 #   undef JITTER_ARG0
56157 #   undef JITTER_ARGN0
56158 #   undef JITTER_ARGU0
56159 #   undef JITTER_ARGP0
56160 #   undef JITTER_ARGF0
56161 
56162 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
56163 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
56164 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
56165 
56166   }
56167 #ifndef JITTER_REPLICATE
56168  JITTER_INSTRUCTION_EPILOG_(*primitive-two-remainder/fR*-no-fast-branches, _Aprimitive_mtwo_mremainder__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
56169 #endif // #ifndef JITTER_REPLICATE
56170 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
56171 
56172   JITTER_INSTRUCTION_PROLOG_(*primitive-two-times/fR*-no-fast-branches, _Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches, hot)
56173   {
56174     /* This specialized instruction is a replacement. */
56175 #   undef JITTER_BRANCH_FAST
56176 #   define JITTER_BRANCH_FAST JITTER_BRANCH
56177 #   undef JITTER_BRANCH_FAST_IF_ZERO
56178 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
56179 #   undef JITTER_BRANCH_FAST_IF_NONZERO
56180 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
56181 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
56182 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
56183 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
56184 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
56185 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
56186 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
56187 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
56188 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
56189 #   undef JITTER_BRANCH_FAST_IF_EQUAL
56190 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
56191 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
56192 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
56193 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
56194 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
56195 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
56196 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
56197 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
56198 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
56199 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
56200 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
56201 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
56202 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
56203 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
56204 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
56205 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
56206 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
56207 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
56208 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
56209 #   undef JITTER_BRANCH_FAST_IF_AND
56210 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
56211 #   undef JITTER_BRANCH_FAST_IF_NOTAND
56212 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
56213 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
56214 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
56215 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
56216 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
56217 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
56218 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
56219 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
56220 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
56221 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
56222 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
56223 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
56224 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
56225 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
56226 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
56227 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
56228 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
56229 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
56230 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
56231 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
56232 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
56233 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
56234 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
56235 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
56236 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
56237 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
56238 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
56239     /* This specialized instruction is non-relocatable.
56240        Its 0-th argument, a literal, is the return address where to jump
56241        at the end, back to relocated code. */
56242 
56243 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       286
56244 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-two-times/fR*-no-fast-branches
56245 
56246 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches
56247 
56248   /* The residual arity for this instruction does not depend on fast labels. */
56249   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
56250 
56251   /* Define argument-access macros for *primitive-two-times/fR*-no-fast-branches . */
56252 #ifdef JITTER_HAVE_PATCH_IN
56253   /* Define argument-access macros assuming that fast branches are enabled. */
56254     /* The 0th argument is a residual label. */
56255 #if defined(JITTER_DISPATCH_NO_THREADING)
56256 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56257     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56258 #elif defined (JITTER_REPLICATE)
56259 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56260 #else
56261 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56262 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56263 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56264 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56265 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56266 #   define JITTER_ARGF0 JITTER_ARGP0
56267 
56268 #else
56269   /* Define argument-access macros assuming that fast branches are disabled. */
56270     /* The 0th argument is a residual label. */
56271 #if defined(JITTER_DISPATCH_NO_THREADING)
56272 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56273     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56274 #elif defined (JITTER_REPLICATE)
56275 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56276 #else
56277 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56278 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56279 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56280 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56281 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56282 #   define JITTER_ARGF0 JITTER_ARGP0
56283 
56284 # endif // #ifdef JITTER_HAVE_PATCH_IN
56285 
56286 #ifdef JITTER_REPLICATE
56287     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
56288        it on the stack rather than in read-only memory.  I had to do this to prevent
56289        a GCC 8 snapshot on SH from being too clever. */
56290     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56291     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
56292        in memory, as a 16-bit constant; and since it reads it with a PC-relative
56293        load the relocated part crashes.
56294                  mov.w     .L1667,r0
56295                  mov.l     @(r0,r15),r1
56296                  jmp       @r1
56297        r15 is the stack pointer.  The constant at .L1667 is
56298           .L1667:
56299                  .short    232
56300        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
56301        can't work as an immediate.  Shall I keep these code pointers as a single array?
56302        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
56303        but the problem will be the same. */
56304     /* Jump to non-relocatable code. */
56305     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56306 
56307     /* Here the residual arity is given as zero: it's too late to
56308        skip residuals, since we've already jumped and this code is
56309        unreachable.  The instruction pointer, if any, is advanced
56310        in the non-relocatable code. */
56311     JITTER_INSTRUCTION_EPILOG_(*primitive-two-times/fR*-no-fast-branches, _Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches, 0)
56312 
56313     /* Relocated code will jump to this label in non-relocated code. */
56314   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
56315     JITTER_COMMENT_IN_ASM_("*primitive-two-times/fR*-no-fast-branches non-relocatable code");
56316 #endif // #ifdef JITTER_REPLICATE
56317 #if defined (JITTER_PROFILE_SAMPLE)
56318   JITTER_PROFILE_SAMPLE_UPDATE
56319      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56320       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56321   /* Force the compiler not move sample-profiling instrumentation
56322      beyond this point; this way the actual user code is timed.
56323      This is still not perfect, as residuals are materialised before
56324      we arrive here, but should be adequate at least for slow VM
56325      instructions. */
56326   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
56327 #endif
56328 #if defined (JITTER_PROFILE_COUNT)
56329   /* Notice that, differently from the code above, this
56330      instrumentation code *can* be reordered freely: as long as a
56331      VM instruction is counted, the count increment can be placed
56332      anyehere.  Let GCC move this code and possibly achieve better
56333      throughput by exploiting instruction-level parallelism and
56334      therefore approximate more closely a non-profiled build. */
56335   JITTER_PROFILE_COUNT_UPDATE
56336      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56337       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56338 #endif
56339 
56340 /* User-specified code, instruction-beginning-c part: beginning. */
56341 
56342 
56343 /* User-specified code, instruction-beginning-c part: end */
56344 
56345 
56346     /* User code for *primitive-two-times/fR*-no-fast-branches . */
56347 
56348     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
56349     JITTERLISP_2TIMES_OR_OVERFLOW_(JITTER_TOP_MAINSTACK(),
56350                                    JITTER_TOP_MAINSTACK(),
56351                                    JITTER_ARGF0);
56352 
56353     /* End of the user code for *primitive-two-times/fR*-no-fast-branches . */
56354 
56355 /* User-specified code, instruction-end-c part: beginning. */
56356 
56357 
56358 /* User-specified code, instruction-end-c part: end */
56359 
56360 #ifdef JITTER_REPLICATE
56361     /* Advance the instruction pointer, if any, to skip residuals;
56362        then jump back to replicated code. */
56363     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
56364     JITTER_SKIP_RESIDUALS_;
56365     goto * _jitter_back_to_replicated_code_pointer;
56366 #endif // #ifdef JITTER_REPLICATE
56367 
56368     /* Undefine the *primitive-two-times/fR*-no-fast-branches argument macros so they can't be used
56369        by mistake in the instruction body coming next. */
56370 #   undef JITTER_SLOW_REGISTER_OFFSET0
56371 #   undef JITTER_ARG0
56372 #   undef JITTER_ARGN0
56373 #   undef JITTER_ARGU0
56374 #   undef JITTER_ARGP0
56375 #   undef JITTER_ARGF0
56376 
56377 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
56378 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
56379 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
56380 
56381   }
56382 #ifndef JITTER_REPLICATE
56383  JITTER_INSTRUCTION_EPILOG_(*primitive-two-times/fR*-no-fast-branches, _Aprimitive_mtwo_mtimes__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
56384 #endif // #ifndef JITTER_REPLICATE
56385 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
56386 
56387   JITTER_INSTRUCTION_PROLOG_(*primitive-zerop/fR*-no-fast-branches, _Aprimitive_mzerop__fR_A_mno_mfast_mbranches, hot)
56388   {
56389     /* This specialized instruction is a replacement. */
56390 #   undef JITTER_BRANCH_FAST
56391 #   define JITTER_BRANCH_FAST JITTER_BRANCH
56392 #   undef JITTER_BRANCH_FAST_IF_ZERO
56393 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
56394 #   undef JITTER_BRANCH_FAST_IF_NONZERO
56395 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
56396 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
56397 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
56398 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
56399 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
56400 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
56401 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
56402 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
56403 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
56404 #   undef JITTER_BRANCH_FAST_IF_EQUAL
56405 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
56406 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
56407 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
56408 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
56409 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
56410 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
56411 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
56412 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
56413 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
56414 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
56415 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
56416 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
56417 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
56418 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
56419 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
56420 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
56421 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
56422 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
56423 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
56424 #   undef JITTER_BRANCH_FAST_IF_AND
56425 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
56426 #   undef JITTER_BRANCH_FAST_IF_NOTAND
56427 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
56428 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
56429 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
56430 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
56431 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
56432 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
56433 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
56434 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
56435 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
56436 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
56437 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
56438 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
56439 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
56440 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
56441 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
56442 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
56443 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
56444 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
56445 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
56446 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
56447 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
56448 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
56449 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
56450 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
56451 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
56452 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
56453 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
56454     /* This specialized instruction is non-relocatable.
56455        Its 0-th argument, a literal, is the return address where to jump
56456        at the end, back to relocated code. */
56457 
56458 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       287
56459 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *primitive-zerop/fR*-no-fast-branches
56460 
56461 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Aprimitive_mzerop__fR_A_mno_mfast_mbranches
56462 
56463   /* The residual arity for this instruction does not depend on fast labels. */
56464   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 1
56465 
56466   /* Define argument-access macros for *primitive-zerop/fR*-no-fast-branches . */
56467 #ifdef JITTER_HAVE_PATCH_IN
56468   /* Define argument-access macros assuming that fast branches are enabled. */
56469     /* The 0th argument is a residual label. */
56470 #if defined(JITTER_DISPATCH_NO_THREADING)
56471 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56472     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56473 #elif defined (JITTER_REPLICATE)
56474 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56475 #else
56476 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56477 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56478 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56479 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56480 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56481 #   define JITTER_ARGF0 JITTER_ARGP0
56482 
56483 #else
56484   /* Define argument-access macros assuming that fast branches are disabled. */
56485     /* The 0th argument is a residual label. */
56486 #if defined(JITTER_DISPATCH_NO_THREADING)
56487 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56488     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56489 #elif defined (JITTER_REPLICATE)
56490 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56491 #else
56492 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56493 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56494 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56495 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56496 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56497 #   define JITTER_ARGF0 JITTER_ARGP0
56498 
56499 # endif // #ifdef JITTER_HAVE_PATCH_IN
56500 
56501 #ifdef JITTER_REPLICATE
56502     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
56503        it on the stack rather than in read-only memory.  I had to do this to prevent
56504        a GCC 8 snapshot on SH from being too clever. */
56505     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56506     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
56507        in memory, as a 16-bit constant; and since it reads it with a PC-relative
56508        load the relocated part crashes.
56509                  mov.w     .L1667,r0
56510                  mov.l     @(r0,r15),r1
56511                  jmp       @r1
56512        r15 is the stack pointer.  The constant at .L1667 is
56513           .L1667:
56514                  .short    232
56515        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
56516        can't work as an immediate.  Shall I keep these code pointers as a single array?
56517        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
56518        but the problem will be the same. */
56519     /* Jump to non-relocatable code. */
56520     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56521 
56522     /* Here the residual arity is given as zero: it's too late to
56523        skip residuals, since we've already jumped and this code is
56524        unreachable.  The instruction pointer, if any, is advanced
56525        in the non-relocatable code. */
56526     JITTER_INSTRUCTION_EPILOG_(*primitive-zerop/fR*-no-fast-branches, _Aprimitive_mzerop__fR_A_mno_mfast_mbranches, 0)
56527 
56528     /* Relocated code will jump to this label in non-relocated code. */
56529   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
56530     JITTER_COMMENT_IN_ASM_("*primitive-zerop/fR*-no-fast-branches non-relocatable code");
56531 #endif // #ifdef JITTER_REPLICATE
56532 #if defined (JITTER_PROFILE_SAMPLE)
56533   JITTER_PROFILE_SAMPLE_UPDATE
56534      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56535       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56536   /* Force the compiler not move sample-profiling instrumentation
56537      beyond this point; this way the actual user code is timed.
56538      This is still not perfect, as residuals are materialised before
56539      we arrive here, but should be adequate at least for slow VM
56540      instructions. */
56541   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
56542 #endif
56543 #if defined (JITTER_PROFILE_COUNT)
56544   /* Notice that, differently from the code above, this
56545      instrumentation code *can* be reordered freely: as long as a
56546      VM instruction is counted, the count increment can be placed
56547      anyehere.  Let GCC move this code and possibly achieve better
56548      throughput by exploiting instruction-level parallelism and
56549      therefore approximate more closely a non-profiled build. */
56550   JITTER_PROFILE_COUNT_UPDATE
56551      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56552       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56553 #endif
56554 
56555 /* User-specified code, instruction-beginning-c part: beginning. */
56556 
56557 
56558 /* User-specified code, instruction-beginning-c part: end */
56559 
56560 
56561     /* User code for *primitive-zerop/fR*-no-fast-branches . */
56562 
56563     JITTERLISPVM_CHECK_TYPES_1(FIXNUM, JITTER_ARGF0);
56564     JITTERLISP_ZEROP_(JITTER_TOP_MAINSTACK(), JITTER_TOP_MAINSTACK());
56565 
56566     /* End of the user code for *primitive-zerop/fR*-no-fast-branches . */
56567 
56568 /* User-specified code, instruction-end-c part: beginning. */
56569 
56570 
56571 /* User-specified code, instruction-end-c part: end */
56572 
56573 #ifdef JITTER_REPLICATE
56574     /* Advance the instruction pointer, if any, to skip residuals;
56575        then jump back to replicated code. */
56576     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP0;
56577     JITTER_SKIP_RESIDUALS_;
56578     goto * _jitter_back_to_replicated_code_pointer;
56579 #endif // #ifdef JITTER_REPLICATE
56580 
56581     /* Undefine the *primitive-zerop/fR*-no-fast-branches argument macros so they can't be used
56582        by mistake in the instruction body coming next. */
56583 #   undef JITTER_SLOW_REGISTER_OFFSET0
56584 #   undef JITTER_ARG0
56585 #   undef JITTER_ARGN0
56586 #   undef JITTER_ARGU0
56587 #   undef JITTER_ARGP0
56588 #   undef JITTER_ARGF0
56589 
56590 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
56591 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
56592 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
56593 
56594   }
56595 #ifndef JITTER_REPLICATE
56596  JITTER_INSTRUCTION_EPILOG_(*primitive-zerop/fR*-no-fast-branches, _Aprimitive_mzerop__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
56597 #endif // #ifndef JITTER_REPLICATE
56598 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
56599 
56600   JITTER_INSTRUCTION_PROLOG_(*push-global/nR/fR*-no-fast-branches, _Apush_mglobal__nR__fR_A_mno_mfast_mbranches, cold)
56601   {
56602     /* This specialized instruction is a replacement. */
56603 #   undef JITTER_BRANCH_FAST
56604 #   define JITTER_BRANCH_FAST JITTER_BRANCH
56605 #   undef JITTER_BRANCH_FAST_IF_ZERO
56606 #   define JITTER_BRANCH_FAST_IF_ZERO JITTER_BRANCH_IF_ZERO
56607 #   undef JITTER_BRANCH_FAST_IF_NONZERO
56608 #   define JITTER_BRANCH_FAST_IF_NONZERO JITTER_BRANCH_IF_NONZERO
56609 #   undef JITTER_BRANCH_FAST_IF_POSITIVE
56610 #   define JITTER_BRANCH_FAST_IF_POSITIVE JITTER_BRANCH_IF_POSITIVE
56611 #   undef JITTER_BRANCH_FAST_IF_NONPOSITIVE
56612 #   define JITTER_BRANCH_FAST_IF_NONPOSITIVE JITTER_BRANCH_IF_NONPOSITIVE
56613 #   undef JITTER_BRANCH_FAST_IF_NEGATIVE
56614 #   define JITTER_BRANCH_FAST_IF_NEGATIVE JITTER_BRANCH_IF_NEGATIVE
56615 #   undef JITTER_BRANCH_FAST_IF_NONNEGATIVE
56616 #   define JITTER_BRANCH_FAST_IF_NONNEGATIVE JITTER_BRANCH_IF_NONNEGATIVE
56617 #   undef JITTER_BRANCH_FAST_IF_EQUAL
56618 #   define JITTER_BRANCH_FAST_IF_EQUAL JITTER_BRANCH_IF_EQUAL
56619 #   undef JITTER_BRANCH_FAST_IF_NOTEQUAL
56620 #   define JITTER_BRANCH_FAST_IF_NOTEQUAL JITTER_BRANCH_IF_NOTEQUAL
56621 #   undef JITTER_BRANCH_FAST_IF_LESS_SIGNED
56622 #   define JITTER_BRANCH_FAST_IF_LESS_SIGNED JITTER_BRANCH_IF_LESS_SIGNED
56623 #   undef JITTER_BRANCH_FAST_IF_LESS_UNSIGNED
56624 #   define JITTER_BRANCH_FAST_IF_LESS_UNSIGNED JITTER_BRANCH_IF_LESS_UNSIGNED
56625 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED
56626 #   define JITTER_BRANCH_FAST_IF_NOTLESS_SIGNED JITTER_BRANCH_IF_NOTLESS_SIGNED
56627 #   undef JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED
56628 #   define JITTER_BRANCH_FAST_IF_NOTLESS_UNSIGNED JITTER_BRANCH_IF_NOTLESS_UNSIGNED
56629 #   undef JITTER_BRANCH_FAST_IF_GREATER_SIGNED
56630 #   define JITTER_BRANCH_FAST_IF_GREATER_SIGNED JITTER_BRANCH_IF_GREATER_SIGNED
56631 #   undef JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED
56632 #   define JITTER_BRANCH_FAST_IF_GREATER_UNSIGNED JITTER_BRANCH_IF_GREATER_UNSIGNED
56633 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED
56634 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_SIGNED JITTER_BRANCH_IF_NOTGREATER_SIGNED
56635 #   undef JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED
56636 #   define JITTER_BRANCH_FAST_IF_NOTGREATER_UNSIGNED JITTER_BRANCH_IF_NOTGREATER_UNSIGNED
56637 #   undef JITTER_BRANCH_FAST_IF_AND
56638 #   define JITTER_BRANCH_FAST_IF_AND JITTER_BRANCH_IF_AND
56639 #   undef JITTER_BRANCH_FAST_IF_NOTAND
56640 #   define JITTER_BRANCH_FAST_IF_NOTAND JITTER_BRANCH_IF_NOTAND
56641 #   undef JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS
56642 #   define JITTER_BRANCH_FAST_IF_PLUS_OVERFLOWS JITTER_BRANCH_IF_PLUS_OVERFLOWS
56643 #   undef JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS
56644 #   define JITTER_BRANCH_FAST_IF_MINUS_OVERFLOWS JITTER_BRANCH_IF_MINUS_OVERFLOWS
56645 #   undef JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS
56646 #   define JITTER_BRANCH_FAST_IF_TIMES_OVERFLOWS JITTER_BRANCH_IF_TIMES_OVERFLOWS
56647 #   undef JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS
56648 #   define JITTER_BRANCH_FAST_IF_DIVIDED_OVERFLOWS JITTER_BRANCH_IF_DIVIDED_OVERFLOWS
56649 #   undef JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS
56650 #   define JITTER_BRANCH_FAST_IF_REMAINDER_OVERFLOWS JITTER_BRANCH_IF_REMAINDER_OVERFLOWS
56651 #   undef JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS
56652 #   define JITTER_BRANCH_FAST_IF_NEGATE_OVERFLOWS JITTER_BRANCH_IF_NEGATE_OVERFLOWS
56653 #   undef JITTER_BRANCH_FAST_AND_LINK_INTERNAL
56654 #   define JITTER_BRANCH_FAST_AND_LINK_INTERNAL JITTER_BRANCH_AND_LINK_INTERNAL
56655 #   undef JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW
56656 #   define JITTER_PLUS_BRANCH_FAST_IF_OVERFLOW JITTER_PLUS_BRANCH_IF_OVERFLOW
56657 #   undef JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW
56658 #   define JITTER_MINUS_BRANCH_FAST_IF_OVERFLOW JITTER_MINUS_BRANCH_IF_OVERFLOW
56659 #   undef JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW
56660 #   define JITTER_TIMES_BRANCH_FAST_IF_OVERFLOW JITTER_TIMES_BRANCH_IF_OVERFLOW
56661 #   undef JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW
56662 #   define JITTER_DIVIDED_BRANCH_FAST_IF_OVERFLOW JITTER_DIVIDED_BRANCH_IF_OVERFLOW
56663 #   undef JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW
56664 #   define JITTER_REMAINDER_BRANCH_FAST_IF_OVERFLOW JITTER_REMAINDER_BRANCH_IF_OVERFLOW
56665 #   undef JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW
56666 #   define JITTER_NEGATE_BRANCH_FAST_IF_OVERFLOW JITTER_NEGATE_BRANCH_IF_OVERFLOW
56667     /* This specialized instruction is non-relocatable.
56668        Its 1-th argument, a literal, is the return address where to jump
56669        at the end, back to relocated code. */
56670 
56671 #   define JITTER_SPECIALIZED_INSTRUCTION_OPCODE       288
56672 #   define JITTER_SPECIALIZED_INSTRUCTION_NAME         *push-global/nR/fR*-no-fast-branches
56673 
56674 #   define JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME _Apush_mglobal__nR__fR_A_mno_mfast_mbranches
56675 
56676   /* The residual arity for this instruction does not depend on fast labels. */
56677   #define JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY 2
56678 
56679   /* Define argument-access macros for *push-global/nR/fR*-no-fast-branches . */
56680 #ifdef JITTER_HAVE_PATCH_IN
56681   /* Define argument-access macros assuming that fast branches are enabled. */
56682     /* The 0th argument is a residual literal. */
56683 #if defined(JITTER_DISPATCH_NO_THREADING)
56684 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56685     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56686 #elif defined (JITTER_REPLICATE)
56687 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56688 #else
56689 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56690 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56691 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56692 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56693 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56694 
56695     /* The 1th argument is a residual label. */
56696 #if defined(JITTER_DISPATCH_NO_THREADING)
56697 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
56698     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
56699 #elif defined (JITTER_REPLICATE)
56700 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
56701 #else
56702 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
56703 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56704 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
56705 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
56706 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
56707 #   define JITTER_ARGF1 JITTER_ARGP1
56708 
56709 #else
56710   /* Define argument-access macros assuming that fast branches are disabled. */
56711     /* The 0th argument is a residual literal. */
56712 #if defined(JITTER_DISPATCH_NO_THREADING)
56713 #   define JITTER_ARG0  JITTER_RESIDUAL_ARGUMENT_0
56714     JITTER_MARK_RESIDUAL_0_AS_SET_BY_ASSEMBLY;
56715 #elif defined (JITTER_REPLICATE)
56716 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[0])
56717 #else
56718 #   define JITTER_ARG0  (((union jitter_word*)jitter_ip)[1])
56719 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56720 #   define JITTER_ARGN0 (JITTER_ARG0.fixnum)
56721 #   define JITTER_ARGU0 (JITTER_ARG0.ufixnum)
56722 #   define JITTER_ARGP0 (JITTER_ARG0.pointer)
56723 #   define JITTER_ARGF0 JITTER_ARGP0
56724 
56725     /* The 1th argument is a residual label. */
56726 #if defined(JITTER_DISPATCH_NO_THREADING)
56727 #   define JITTER_ARG1  JITTER_RESIDUAL_ARGUMENT_1
56728     JITTER_MARK_RESIDUAL_1_AS_SET_BY_ASSEMBLY;
56729 #elif defined (JITTER_REPLICATE)
56730 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[1])
56731 #else
56732 #   define JITTER_ARG1  (((union jitter_word*)jitter_ip)[2])
56733 #endif // #if defined(JITTER_DISPATCH_NO_THREADING)
56734 #   define JITTER_ARGN1 (JITTER_ARG1.fixnum)
56735 #   define JITTER_ARGU1 (JITTER_ARG1.ufixnum)
56736 #   define JITTER_ARGP1 (JITTER_ARG1.pointer)
56737 #   define JITTER_ARGF1 JITTER_ARGP1
56738 
56739 # endif // #ifdef JITTER_HAVE_PATCH_IN
56740 
56741 #ifdef JITTER_REPLICATE
56742     /* Pretend to modify the non-relocatable code pointer, to force GCC to keep
56743        it on the stack rather than in read-only memory.  I had to do this to prevent
56744        a GCC 8 snapshot on SH from being too clever. */
56745     //JITTER_MARK_MEMORY_AS_SET_BY_ASSEMBLY(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56746     /* FIXME: no, it's not enough.  GCC 8 on SH keeps the stack pointer *offset*
56747        in memory, as a 16-bit constant; and since it reads it with a PC-relative
56748        load the relocated part crashes.
56749                  mov.w     .L1667,r0
56750                  mov.l     @(r0,r15),r1
56751                  jmp       @r1
56752        r15 is the stack pointer.  The constant at .L1667 is
56753           .L1667:
56754                  .short    232
56755        and this explains everything: 232 doesn't fit in a byte sign-extended, so it
56756        can't work as an immediate.  Shall I keep these code pointers as a single array?
56757        I don't know.  I'll switch to GNU C nested functions for non-relocatable code,
56758        but the problem will be the same. */
56759     /* Jump to non-relocatable code. */
56760     JITTER_COMPUTED_GOTO(JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_VARIABLE);
56761 
56762     /* Here the residual arity is given as zero: it's too late to
56763        skip residuals, since we've already jumped and this code is
56764        unreachable.  The instruction pointer, if any, is advanced
56765        in the non-relocatable code. */
56766     JITTER_INSTRUCTION_EPILOG_(*push-global/nR/fR*-no-fast-branches, _Apush_mglobal__nR__fR_A_mno_mfast_mbranches, 0)
56767 
56768     /* Relocated code will jump to this label in non-relocated code. */
56769   JITTER_SPECIALIZED_INSTRUCTION_NON_RELOCATABLE_CODE_LABEL:
56770     JITTER_COMMENT_IN_ASM_("*push-global/nR/fR*-no-fast-branches non-relocatable code");
56771 #endif // #ifdef JITTER_REPLICATE
56772 #if defined (JITTER_PROFILE_SAMPLE)
56773   JITTER_PROFILE_SAMPLE_UPDATE
56774      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56775       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56776   /* Force the compiler not move sample-profiling instrumentation
56777      beyond this point; this way the actual user code is timed.
56778      This is still not perfect, as residuals are materialised before
56779      we arrive here, but should be adequate at least for slow VM
56780      instructions. */
56781   JITTER_PRETEND_TO_POSSIBLY_JUMP_ANYWHERE ();
56782 #endif
56783 #if defined (JITTER_PROFILE_COUNT)
56784   /* Notice that, differently from the code above, this
56785      instrumentation code *can* be reordered freely: as long as a
56786      VM instruction is counted, the count increment can be placed
56787      anyehere.  Let GCC move this code and possibly achieve better
56788      throughput by exploiting instruction-level parallelism and
56789      therefore approximate more closely a non-profiled build. */
56790   JITTER_PROFILE_COUNT_UPDATE
56791      (JITTERLISPVM_OWN_SPECIAL_PURPOSE_STATE_DATA,
56792       JITTER_SPECIALIZED_INSTRUCTION_OPCODE);
56793 #endif
56794 
56795 /* User-specified code, instruction-beginning-c part: beginning. */
56796 
56797 
56798 /* User-specified code, instruction-beginning-c part: end */
56799 
56800 
56801     /* User code for *push-global/nR/fR*-no-fast-branches . */
56802 
56803     jitterlisp_object tagged_symbol = JITTER_ARGN0;
56804     struct jitterlisp_symbol * symbol = JITTERLISP_SYMBOL_DECODE(tagged_symbol);
56805 
56806 #ifndef JITTERLISP_UNSAFE
56807     JITTER_BRANCH_FAST_IF_EQUAL (symbol->global_value, JITTERLISP_UNDEFINED,
56808                                  JITTER_ARGF1);
56809 #endif // #ifndef JITTERLISP_UNSAFE
56810 
56811 //    JITTER_PUSH_MAINSTACK(symbol->global_value);
56812     JITTER_PUSH_UNSPECIFIED_MAINSTACK();
56813     JITTER_TOP_MAINSTACK() = symbol->global_value;
56814 
56815     /* End of the user code for *push-global/nR/fR*-no-fast-branches . */
56816 
56817 /* User-specified code, instruction-end-c part: beginning. */
56818 
56819 
56820 /* User-specified code, instruction-end-c part: end */
56821 
56822 #ifdef JITTER_REPLICATE
56823     /* Advance the instruction pointer, if any, to skip residuals;
56824        then jump back to replicated code. */
56825     const void *_jitter_back_to_replicated_code_pointer = JITTER_ARGP1;
56826     JITTER_SKIP_RESIDUALS_;
56827     goto * _jitter_back_to_replicated_code_pointer;
56828 #endif // #ifdef JITTER_REPLICATE
56829 
56830     /* Undefine the *push-global/nR/fR*-no-fast-branches argument macros so they can't be used
56831        by mistake in the instruction body coming next. */
56832 #   undef JITTER_SLOW_REGISTER_OFFSET0
56833 #   undef JITTER_ARG0
56834 #   undef JITTER_ARGN0
56835 #   undef JITTER_ARGU0
56836 #   undef JITTER_ARGP0
56837 #   undef JITTER_ARGF0
56838 #   undef JITTER_SLOW_REGISTER_OFFSET1
56839 #   undef JITTER_ARG1
56840 #   undef JITTER_ARGN1
56841 #   undef JITTER_ARGU1
56842 #   undef JITTER_ARGP1
56843 #   undef JITTER_ARGF1
56844 
56845 #   undef JITTER_SPECIALIZED_INSTRUCTION_OPCODE
56846 #   undef JITTER_SPECIALIZED_INSTRUCTION_NAME
56847 #   undef JITTER_SPECIALIZED_INSTRUCTION_MANGLED_NAME
56848 
56849   }
56850 #ifndef JITTER_REPLICATE
56851  JITTER_INSTRUCTION_EPILOG_(*push-global/nR/fR*-no-fast-branches, _Apush_mglobal__nR__fR_A_mno_mfast_mbranches, JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY)
56852 #endif // #ifndef JITTER_REPLICATE
56853 #   undef JITTER_SPECIALIZED_INSTRUCTION_RESIDUAL_ARITY
56854 
56855   /* End of the ordinary specialized instructions. */
56856 
56857 #ifdef JITTER_DISPATCH_SWITCH
56858   default:
56859     jitter_fatal ("invalid opcode %li for VM specialized instruction",
56860                   (long) jitter_ip->fixnum);
56861   } /* switch */
56862 #endif // #ifdef JITTER_DISPATCH_SWITCH
56863 
56864   /* The code jumps here when executing the special specialized instruction
56865      EXITVM, or on a call to the macro JITTER_EXIT from an ordinary specialized
56866      instruction.  This code is *not* replicated: when replication is enabled
56867      jumping here means crossing the boundary from the fragaile replicated
56868      code back into ordinary compiled C, where PC-relative addressing works. */
56869   jitter_exit_vm_label: __attribute__ ((cold));
56870     JITTER_COMMENT_IN_ASM_("About to exit the function");
56871     // fprintf (stderr, "Restoring the VM state to the struct...\n");
56872     /* Copy the VM state from the local copy we have modified back to
56873        the structure to which we received a pointer. */
56874     jitter_original_state->jitterlispvm_state_runtime = jitter_state_runtime;
56875 
56876     // fprintf (stderr, "Exiting the VM...\n");
56877 
56878 
56879 #if defined (JITTER_PROFILE_SAMPLE)
56880     /* Stop sample-profiling: this stops the periodic timer signal, while
56881        we are no longer updating the current instruction field within the
56882        special-purpose struct in the Array. */
56883     jitterlispvm_profile_sample_stop ();
56884 #endif // #if defined (JITTER_PROFILE_SAMPLE)
56885 
56886 #ifndef JITTER_DISPATCH_SWITCH
56887   JITTER_DATA_LOCATION_FOOTER(jitterlispvm);
56888 #endif // #ifndef JITTER_DISPATCH_SWITCH
56889 #ifdef JITTER_HAVE_PATCH_IN
56890   /* Close the patch-in global definition for this executor.  This defines a
56891      new global in the patch-in subsection, holding the descriptor number.
56892      This is a global asm statement.  Same for defects.  See the comment before
56893       the JITTER_PATCH_IN_HEADER use above. */
56894   JITTER_PATCH_IN_FOOTER(jitterlispvm);
56895   JITTER_DEFECT_FOOTER(jitterlispvm);
56896 #endif // #ifdef JITTER_HAVE_PATCH_IN
56897 
56898   /* Finalization C code from the user */
56899 
56900     /* End of the finalization C code from the user */
56901 
56902 
56903   /* Execute architecture-specific execution-end code, if any.  Make
56904      sure it is safe to expand the macro without do..while (false). */
56905   {}; JITTER_EXECUTION_END_; {};
56906 
56907   /* This program point is reachable for both thread initialization and
56908      execution.  In either case it is not performance-critical. */
56909   jitter_possibly_restore_registers_and_return_label: __attribute__ ((cold));
56910     //if (jitter_initialize) puts ("-- RETURNING FROM INITIALIZATION\n");
56911 #ifdef JITTER_DISPATCH_NO_THREADING
56912     /* Back to regular C without our reserved registers: restore the
56913        values held in such registers at entry. */
56914     jitterlispvm_restore_registers (jitter_register_buffer);
56915 #endif // #ifdef JITTER_DISPATCH_NO_THREADING
56916 #ifdef JITTER_PROFILE
56917 #define PROFILING_SPACE (1024 * 1024 * 100)
56918     if (jitter_initialize)
56919       fprintf (stderr, "Profiling space: [%p, %p)\n", && jitterlispvm_profiling_space, ((char *) (&& jitterlispvm_profiling_space)) + PROFILING_SPACE);
56920     /* Do an indirect jump to the return statement rather than a simple
56921        conditional.  With this trick I can afford even a very large gap
56922        within the code for a single C function, without being constrained
56923        by branch offset limits on any architecture. */
56924     void *return_address_variable = && return_label;
56925     JITTER_MARK_LVALUE_AS_SET_BY_ASSEMBLY (return_address_variable);
56926     goto *return_address_variable;
56927   jitterlispvm_profiling_space: __attribute__ ((unused)) // FIXME: do this from assembly
56928     asm volatile (".fill (" JITTER_STRINGIFY(PROFILING_SPACE) ")");
56929   return_label:
56930 #endif // #ifdef JITTER_PROFILE
56931     return;
56932 }
56933 
56934