ci: push perf test metrics even when the testsuite doesn't pass
[ghc.git] / rts / StgMiscClosures.cmm
1 /* ----------------------------------------------------------------------------
2  *
3  * (c) The GHC Team, 1998-2004
4  *
5  * Entry code for various built-in closure types.
6  *
7  * This file is written in a subset of C--, extended with various
8  * features specific to GHC.  It is compiled by GHC directly.  For the
9  * syntax of .cmm files, see the parser in ghc/compiler/cmm/CmmParse.y.
10  *
11  * --------------------------------------------------------------------------*/
12
13 #include "Cmm.h"
14
15 import pthread_mutex_lock;
16 import ghczmprim_GHCziTypes_Czh_info;
17 import ghczmprim_GHCziTypes_Izh_info;
18 import EnterCriticalSection;
19 import LeaveCriticalSection;
20
21 /* ----------------------------------------------------------------------------
22    Stack underflow
23    ------------------------------------------------------------------------- */
24
25 INFO_TABLE_RET (stg_stack_underflow_frame, UNDERFLOW_FRAME,
26                 W_ info_ptr, P_ unused)
27     /* no args => explicit stack */
28 {
29     unwind Sp = W_[Sp + WDS(2)];
30
31     W_ new_tso;
32     W_ ret_off;
33
34     SAVE_STGREGS
35
36     SAVE_THREAD_STATE();
37     (ret_off) = foreign "C" threadStackUnderflow(MyCapability() "ptr",
38                                                  CurrentTSO);
39     LOAD_THREAD_STATE();
40
41     RESTORE_STGREGS
42
43     jump %ENTRY_CODE(Sp(ret_off)) [*]; // NB. all registers live!
44 }
45
46 /* ----------------------------------------------------------------------------
47    Restore a saved cost centre
48    ------------------------------------------------------------------------- */
49
50 INFO_TABLE_RET (stg_restore_cccs, RET_SMALL, W_ info_ptr, W_ cccs)
51 {
52     unwind Sp = Sp + WDS(2);
53 #if defined(PROFILING)
54     CCCS = Sp(1);
55 #endif
56     Sp_adj(2);
57     jump %ENTRY_CODE(Sp(0)) [*]; // NB. all registers live!
58 }
59
60
61 INFO_TABLE_RET (stg_restore_cccs_eval, RET_SMALL, W_ info_ptr, W_ cccs)
62     return (P_ ret)
63 {
64     unwind Sp = Sp + WDS(2);
65 #if defined(PROFILING)
66     CCCS = cccs;
67 #endif
68     jump stg_ap_0_fast(ret);
69 }
70
71 /* ----------------------------------------------------------------------------
72    Support for the bytecode interpreter.
73    ------------------------------------------------------------------------- */
74
75 /* 7 bits of return code for constructors created by the interpreter. */
76 stg_interp_constr1_entry (P_ ret) { return (ret + 1); }
77 stg_interp_constr2_entry (P_ ret) { return (ret + 2); }
78 stg_interp_constr3_entry (P_ ret) { return (ret + 3); }
79 stg_interp_constr4_entry (P_ ret) { return (ret + 4); }
80 stg_interp_constr5_entry (P_ ret) { return (ret + 5); }
81 stg_interp_constr6_entry (P_ ret) { return (ret + 6); }
82 stg_interp_constr7_entry (P_ ret) { return (ret + 7); }
83
84 /* Some info tables to be used when compiled code returns a value to
85    the interpreter, i.e. the interpreter pushes one of these onto the
86    stack before entering a value.  What the code does is to
87    impedance-match the compiled return convention (in R1p/R1n/F1/D1 etc) to
88    the interpreter's convention (returned value is on top of stack),
89    and then cause the scheduler to enter the interpreter.
90
91    On entry, the stack (growing down) looks like this:
92
93       ptr to BCO holding return continuation
94       ptr to one of these info tables.
95
96    The info table code, both direct and vectored, must:
97       * push R1/F1/D1 on the stack, and its tag if necessary
98       * push the BCO (so it's now on the stack twice)
99       * Yield, ie, go to the scheduler.
100
101    Scheduler examines the t.o.s, discovers it is a BCO, and proceeds
102    directly to the bytecode interpreter.  That pops the top element
103    (the BCO, containing the return continuation), and interprets it.
104    Net result: return continuation gets interpreted, with the
105    following stack:
106
107       ptr to this BCO
108       ptr to the info table just jumped thru
109       return value
110
111    which is just what we want -- the "standard" return layout for the
112    interpreter.  Hurrah!
113
114    Don't ask me how unboxed tuple returns are supposed to work.  We
115    haven't got a good story about that yet.
116 */
117
118 INFO_TABLE_RET( stg_ctoi_R1p, RET_BCO)
119     /* explicit stack */
120 {
121     Sp_adj(-2);
122     Sp(1) = R1;
123     Sp(0) = stg_enter_info;
124     jump stg_yield_to_interpreter [];
125 }
126
127 /*
128  * When the returned value is a pointer, but unlifted, in R1 ...
129  */
130 INFO_TABLE_RET( stg_ctoi_R1unpt, RET_BCO )
131     /* explicit stack */
132 {
133     Sp_adj(-2);
134     Sp(1) = R1;
135     Sp(0) = stg_ret_p_info;
136     jump stg_yield_to_interpreter [];
137 }
138
139 /*
140  * When the returned value is a non-pointer in R1 ...
141  */
142 INFO_TABLE_RET( stg_ctoi_R1n, RET_BCO )
143     /* explicit stack */
144 {
145     Sp_adj(-2);
146     Sp(1) = R1;
147     Sp(0) = stg_ret_n_info;
148     jump stg_yield_to_interpreter [];
149 }
150
151 /*
152  * When the returned value is in F1
153  */
154 INFO_TABLE_RET( stg_ctoi_F1, RET_BCO )
155     /* explicit stack */
156 {
157     Sp_adj(-2);
158     F_[Sp + WDS(1)] = F1;
159     Sp(0) = stg_ret_f_info;
160     jump stg_yield_to_interpreter [];
161 }
162
163 /*
164  * When the returned value is in D1
165  */
166 INFO_TABLE_RET( stg_ctoi_D1, RET_BCO )
167     /* explicit stack */
168 {
169     Sp_adj(-1) - SIZEOF_DOUBLE;
170     D_[Sp + WDS(1)] = D1;
171     Sp(0) = stg_ret_d_info;
172     jump stg_yield_to_interpreter [];
173 }
174
175 /*
176  * When the returned value is in L1
177  */
178 INFO_TABLE_RET( stg_ctoi_L1, RET_BCO )
179     /* explicit stack */
180 {
181     Sp_adj(-1) - 8;
182     L_[Sp + WDS(1)] = L1;
183     Sp(0) = stg_ret_l_info;
184     jump stg_yield_to_interpreter [];
185 }
186
187 /*
188  * When the returned value is a void
189  */
190 INFO_TABLE_RET( stg_ctoi_V, RET_BCO )
191     /* explicit stack */
192 {
193     Sp_adj(-1);
194     Sp(0) = stg_ret_v_info;
195     jump stg_yield_to_interpreter [];
196 }
197
198 /*
199  * Dummy info table pushed on the top of the stack when the interpreter
200  * should apply the BCO on the stack to its arguments, also on the
201  * stack.
202  */
203 INFO_TABLE_RET( stg_apply_interp, RET_BCO )
204     /* explicit stack */
205 {
206     /* Just in case we end up in here... (we shouldn't) */
207     jump stg_yield_to_interpreter [];
208 }
209
210 /* ----------------------------------------------------------------------------
211    Entry code for a BCO
212    ------------------------------------------------------------------------- */
213
214 INFO_TABLE_FUN( stg_BCO, 3, 0, BCO, "BCO", "BCO", ARG_BCO )
215     /* explicit stack */
216 {
217   /* entering a BCO means "apply it", same as a function */
218   Sp_adj(-2);
219   // Skip the stack check; the interpreter will do one before using
220   // the stack anyway.
221   Sp(1) = R1;
222   Sp(0) = stg_apply_interp_info;
223   jump stg_yield_to_interpreter [];
224 }
225
226 /* ----------------------------------------------------------------------------
227    Info tables for indirections.
228
229    SPECIALISED INDIRECTIONS: we have a specialised indirection for direct returns,
230    so that we can avoid entering
231    the object when we know it points directly to a value.  The update
232    code (Updates.cmm) updates objects with the appropriate kind of
233    indirection.  We only do this for young-gen indirections.
234    ------------------------------------------------------------------------- */
235
236 INFO_TABLE(stg_IND,1,0,IND,"IND","IND")
237 #if 0
238 /*
239   This version in high-level cmm generates slightly less good code
240   than the low-level version below it. (ToDo)
241 */
242     (P_ node)
243 {
244     TICK_ENT_DYN_IND(); /* tick */
245     node = UNTAG(StgInd_indirectee(node));
246     TICK_ENT_VIA_NODE();
247     jump %GET_ENTRY(node) (node);
248 }
249 #else
250     /* explicit stack */
251 {
252     TICK_ENT_DYN_IND(); /* tick */
253     R1 = UNTAG(StgInd_indirectee(R1));
254     TICK_ENT_VIA_NODE();
255     jump %GET_ENTRY(R1) [R1];
256 }
257 #endif
258
259 INFO_TABLE(stg_IND_direct,1,0,IND,"IND","IND")
260     (P_ node)
261 {
262     TICK_ENT_DYN_IND(); /* tick */
263     node = StgInd_indirectee(node);
264     TICK_ENT_VIA_NODE();
265     jump %ENTRY_CODE(Sp(0)) (node);
266 }
267
268 INFO_TABLE(stg_IND_STATIC,1,0,IND_STATIC,"IND_STATIC","IND_STATIC")
269     /* explicit stack */
270 {
271     TICK_ENT_STATIC_IND(); /* tick */
272     R1 = UNTAG(StgInd_indirectee(R1));
273     TICK_ENT_VIA_NODE();
274     jump %GET_ENTRY(R1) [R1];
275 }
276
277 /* ----------------------------------------------------------------------------
278    Black holes.
279
280    Entering a black hole normally causes a cyclic data dependency, but
281    in the concurrent world, black holes are synchronization points,
282    and they are turned into blocking queues when there are threads
283    waiting for the evaluation of the closure to finish.
284    ------------------------------------------------------------------------- */
285
286 INFO_TABLE(stg_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE")
287     (P_ node)
288 {
289     W_ r, info, owner, bd;
290     P_ p, bq, msg;
291
292     TICK_ENT_DYN_IND(); /* tick */
293
294 retry:
295     prim_read_barrier;
296     p = StgInd_indirectee(node);
297     if (GETTAG(p) != 0) {
298         return (p);
299     }
300
301     info = StgHeader_info(p);
302     prim_read_barrier;
303     if (info == stg_IND_info) {
304         // This could happen, if e.g. we got a BLOCKING_QUEUE that has
305         // just been replaced with an IND by another thread in
306         // wakeBlockingQueue().
307         // See Note [BLACKHOLE pointing to IND] in sm/Evac.c
308         goto retry;
309     }
310
311     if (info == stg_TSO_info ||
312         info == stg_BLOCKING_QUEUE_CLEAN_info ||
313         info == stg_BLOCKING_QUEUE_DIRTY_info)
314     {
315         ("ptr" msg) = ccall allocate(MyCapability() "ptr",
316                                      BYTES_TO_WDS(SIZEOF_MessageBlackHole));
317
318         MessageBlackHole_tso(msg) = CurrentTSO;
319         MessageBlackHole_bh(msg) = node;
320         SET_HDR(msg, stg_MSG_BLACKHOLE_info, CCS_SYSTEM);
321         // messageBlackHole has appropriate memory barriers when this object is exposed.
322         // See Note [Heap memory barriers].
323
324         (r) = ccall messageBlackHole(MyCapability() "ptr", msg "ptr");
325
326         if (r == 0) {
327             goto retry;
328         } else {
329             StgTSO_why_blocked(CurrentTSO) = BlockedOnBlackHole::I16;
330             StgTSO_block_info(CurrentTSO) = msg;
331             jump stg_block_blackhole(node);
332         }
333     }
334     else
335     {
336         ENTER(p);
337     }
338 }
339
340 // CAF_BLACKHOLE is allocated when entering a CAF.  The reason it is
341 // distinct from BLACKHOLE is so that we can tell the difference
342 // between an update frame on the stack that points to a CAF under
343 // evaluation, and one that points to a closure that is under
344 // evaluation by another thread (a BLACKHOLE).  see Note [suspend
345 // duplicate work] in ThreadPaused.c
346 //
347 INFO_TABLE(stg_CAF_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE")
348     (P_ node)
349 {
350     jump ENTRY_LBL(stg_BLACKHOLE) (node);
351 }
352
353 // EAGER_BLACKHOLE exists for the same reason as CAF_BLACKHOLE (see above).
354 INFO_TABLE(__stg_EAGER_BLACKHOLE,1,0,BLACKHOLE,"BLACKHOLE","BLACKHOLE")
355     (P_ node)
356 {
357     jump ENTRY_LBL(stg_BLACKHOLE) (node);
358 }
359
360 INFO_TABLE(stg_BLOCKING_QUEUE_CLEAN,4,0,BLOCKING_QUEUE,"BLOCKING_QUEUE","BLOCKING_QUEUE")
361 { foreign "C" barf("BLOCKING_QUEUE_CLEAN object (%p) entered!", R1) never returns; }
362
363
364 INFO_TABLE(stg_BLOCKING_QUEUE_DIRTY,4,0,BLOCKING_QUEUE,"BLOCKING_QUEUE","BLOCKING_QUEUE")
365 { foreign "C" barf("BLOCKING_QUEUE_DIRTY object (%p) entered!", R1) never returns; }
366
367
368 /* ----------------------------------------------------------------------------
369    Whiteholes are used for the "locked" state of a closure (see lockClosure())
370    ------------------------------------------------------------------------- */
371
372 INFO_TABLE(stg_WHITEHOLE, 0,0, WHITEHOLE, "WHITEHOLE", "WHITEHOLE")
373     (P_ node)
374 {
375 #if defined(THREADED_RTS)
376     W_ info, i;
377
378     i = 0;
379 loop:
380     // spin until the WHITEHOLE is updated
381     info = StgHeader_info(node);
382     if (info == stg_WHITEHOLE_info) {
383 #if defined(PROF_SPIN)
384         W_[whitehole_lockClosure_spin] =
385             W_[whitehole_lockClosure_spin] + 1;
386 #endif
387         i = i + 1;
388         if (i == SPIN_COUNT) {
389             i = 0;
390 #if defined(PROF_SPIN)
391             W_[whitehole_lockClosure_yield] =
392                 W_[whitehole_lockClosure_yield] + 1;
393 #endif
394             ccall yieldThread();
395         }
396         // TODO: We should busy_wait_nop() here, but that's not currently
397         // defined in CMM.
398         goto loop;
399     }
400     jump %ENTRY_CODE(info) (node);
401 #else
402     ccall barf("WHITEHOLE object (%p) entered!", R1) never returns;
403 #endif
404 }
405
406 /* ----------------------------------------------------------------------------
407    Some static info tables for things that don't get entered, and
408    therefore don't need entry code (i.e. boxed but unpointed objects)
409    NON_ENTERABLE_ENTRY_CODE now defined at the beginning of the file
410    ------------------------------------------------------------------------- */
411
412 INFO_TABLE(stg_TSO, 0,0,TSO, "TSO", "TSO")
413 { foreign "C" barf("TSO object (%p) entered!", R1) never returns; }
414
415 INFO_TABLE(stg_STACK, 0,0, STACK, "STACK", "STACK")
416 { foreign "C" barf("STACK object (%p) entered!", R1) never returns; }
417
418 /* ----------------------------------------------------------------------------
419    Weak pointers
420
421    Live weak pointers have a special closure type.  Dead ones are just
422    nullary constructors (although they live on the heap - we overwrite
423    live weak pointers with dead ones).
424    ------------------------------------------------------------------------- */
425
426 INFO_TABLE(stg_WEAK,1,4,WEAK,"WEAK","WEAK")
427 { foreign "C" barf("WEAK object (%p) entered!", R1) never returns; }
428
429 /*
430  * It's important when turning an existing WEAK into a DEAD_WEAK
431  * (which is what finalizeWeak# does) that we don't lose the link
432  * field and break the linked list of weak pointers.  Hence, we give
433  * DEAD_WEAK 5 non-pointer fields.
434  */
435 INFO_TABLE_CONSTR(stg_DEAD_WEAK,0,5,0,CONSTR,"DEAD_WEAK","DEAD_WEAK")
436 { foreign "C" barf("DEAD_WEAK object (%p) entered!", R1) never returns; }
437
438 /* ----------------------------------------------------------------------------
439    C finalizer lists
440
441    Singly linked lists that chain multiple C finalizers on a weak pointer.
442    ------------------------------------------------------------------------- */
443
444 INFO_TABLE_CONSTR(stg_C_FINALIZER_LIST,1,4,0,CONSTR,"C_FINALIZER_LIST","C_FINALIZER_LIST")
445 { foreign "C" barf("C_FINALIZER_LIST object (%p) entered!", R1) never returns; }
446
447 /* ----------------------------------------------------------------------------
448    NO_FINALIZER
449
450    This is a static nullary constructor (like []) that we use to mark an empty
451    finalizer in a weak pointer object.
452    ------------------------------------------------------------------------- */
453
454 INFO_TABLE_CONSTR(stg_NO_FINALIZER,0,0,0,CONSTR_NOCAF,"NO_FINALIZER","NO_FINALIZER")
455 { foreign "C" barf("NO_FINALIZER object (%p) entered!", R1) never returns; }
456
457 CLOSURE(stg_NO_FINALIZER_closure,stg_NO_FINALIZER);
458
459 /* ----------------------------------------------------------------------------
460    Stable Names are unlifted too.
461    ------------------------------------------------------------------------- */
462
463 INFO_TABLE(stg_STABLE_NAME,0,1,PRIM,"STABLE_NAME","STABLE_NAME")
464 { foreign "C" barf("STABLE_NAME object (%p) entered!", R1) never returns; }
465
466 /* ----------------------------------------------------------------------------
467    MVars
468
469    There are two kinds of these: full and empty.  We need an info table
470    and entry code for each type.
471    ------------------------------------------------------------------------- */
472
473 INFO_TABLE(stg_MVAR_CLEAN,3,0,MVAR_CLEAN,"MVAR","MVAR")
474 { foreign "C" barf("MVAR object (%p) entered!", R1) never returns; }
475
476 INFO_TABLE(stg_MVAR_DIRTY,3,0,MVAR_DIRTY,"MVAR","MVAR")
477 { foreign "C" barf("MVAR object (%p) entered!", R1) never returns; }
478
479 /* -----------------------------------------------------------------------------
480    STM
481    -------------------------------------------------------------------------- */
482
483 INFO_TABLE(stg_TVAR_CLEAN, 2, 1, TVAR, "TVAR", "TVAR")
484 { foreign "C" barf("TVAR_CLEAN object (%p) entered!", R1) never returns; }
485
486 INFO_TABLE(stg_TVAR_DIRTY, 2, 1, TVAR, "TVAR", "TVAR")
487 { foreign "C" barf("TVAR_DIRTY object (%p) entered!", R1) never returns; }
488
489 INFO_TABLE(stg_TVAR_WATCH_QUEUE, 3, 0, MUT_PRIM, "TVAR_WATCH_QUEUE", "TVAR_WATCH_QUEUE")
490 { foreign "C" barf("TVAR_WATCH_QUEUE object (%p) entered!", R1) never returns; }
491
492 INFO_TABLE(stg_TREC_CHUNK, 0, 0, TREC_CHUNK, "TREC_CHUNK", "TREC_CHUNK")
493 { foreign "C" barf("TREC_CHUNK object (%p) entered!", R1) never returns; }
494
495 INFO_TABLE(stg_TREC_HEADER, 2, 1, MUT_PRIM, "TREC_HEADER", "TREC_HEADER")
496 { foreign "C" barf("TREC_HEADER object (%p) entered!", R1) never returns; }
497
498 INFO_TABLE_CONSTR(stg_END_STM_WATCH_QUEUE,0,0,0,CONSTR_NOCAF,"END_STM_WATCH_QUEUE","END_STM_WATCH_QUEUE")
499 { foreign "C" barf("END_STM_WATCH_QUEUE object (%p) entered!", R1) never returns; }
500
501 INFO_TABLE_CONSTR(stg_END_STM_CHUNK_LIST,0,0,0,CONSTR_NOCAF,"END_STM_CHUNK_LIST","END_STM_CHUNK_LIST")
502 { foreign "C" barf("END_STM_CHUNK_LIST object (%p) entered!", R1) never returns; }
503
504 INFO_TABLE_CONSTR(stg_NO_TREC,0,0,0,CONSTR_NOCAF,"NO_TREC","NO_TREC")
505 { foreign "C" barf("NO_TREC object (%p) entered!", R1) never returns; }
506
507 CLOSURE(stg_END_STM_WATCH_QUEUE_closure,stg_END_STM_WATCH_QUEUE);
508
509 CLOSURE(stg_END_STM_CHUNK_LIST_closure,stg_END_STM_CHUNK_LIST);
510
511 CLOSURE(stg_NO_TREC_closure,stg_NO_TREC);
512
513 /* ----------------------------------------------------------------------------
514    SRTs
515
516    See Note [SRTs] in compiler/cmm/CmmBuildInfoTable.hs
517    ------------------------------------------------------------------------- */
518
519 INFO_TABLE_CONSTR(stg_SRT_1, 1, 0, 0, CONSTR_1_0, "SRT_1", "SRT_1")
520 { foreign "C" barf("SRT_1 object (%p) entered!", R1) never returns; }
521
522 INFO_TABLE_CONSTR(stg_SRT_2, 2, 0, 0, CONSTR_2_0, "SRT_2", "SRT_2")
523 { foreign "C" barf("SRT_2 object (%p) entered!", R1) never returns; }
524
525 INFO_TABLE_CONSTR(stg_SRT_3, 3, 0, 0, CONSTR, "SRT_3", "SRT_3")
526 { foreign "C" barf("SRT_3 object (%p) entered!", R1) never returns; }
527
528 INFO_TABLE_CONSTR(stg_SRT_4, 4, 0, 0, CONSTR, "SRT_4", "SRT_4")
529 { foreign "C" barf("SRT_4 object (%p) entered!", R1) never returns; }
530
531 INFO_TABLE_CONSTR(stg_SRT_5, 5, 0, 0, CONSTR, "SRT_5", "SRT_5")
532 { foreign "C" barf("SRT_5 object (%p) entered!", R1) never returns; }
533
534 INFO_TABLE_CONSTR(stg_SRT_6, 6, 0, 0, CONSTR, "SRT_6", "SRT_6")
535 { foreign "C" barf("SRT_6 object (%p) entered!", R1) never returns; }
536
537 INFO_TABLE_CONSTR(stg_SRT_7, 7, 0, 0, CONSTR, "SRT_7", "SRT_7")
538 { foreign "C" barf("SRT_7 object (%p) entered!", R1) never returns; }
539
540 INFO_TABLE_CONSTR(stg_SRT_8, 8, 0, 0, CONSTR, "SRT_8", "SRT_8")
541 { foreign "C" barf("SRT_8 object (%p) entered!", R1) never returns; }
542
543 INFO_TABLE_CONSTR(stg_SRT_9, 9, 0, 0, CONSTR, "SRT_9", "SRT_9")
544 { foreign "C" barf("SRT_9 object (%p) entered!", R1) never returns; }
545
546 INFO_TABLE_CONSTR(stg_SRT_10, 10, 0, 0, CONSTR, "SRT_10", "SRT_10")
547 { foreign "C" barf("SRT_10 object (%p) entered!", R1) never returns; }
548
549 INFO_TABLE_CONSTR(stg_SRT_11, 11, 0, 0, CONSTR, "SRT_11", "SRT_11")
550 { foreign "C" barf("SRT_11 object (%p) entered!", R1) never returns; }
551
552 INFO_TABLE_CONSTR(stg_SRT_12, 12, 0, 0, CONSTR, "SRT_12", "SRT_12")
553 { foreign "C" barf("SRT_12 object (%p) entered!", R1) never returns; }
554
555 INFO_TABLE_CONSTR(stg_SRT_13, 13, 0, 0, CONSTR, "SRT_13", "SRT_13")
556 { foreign "C" barf("SRT_13 object (%p) entered!", R1) never returns; }
557
558 INFO_TABLE_CONSTR(stg_SRT_14, 14, 0, 0, CONSTR, "SRT_14", "SRT_14")
559 { foreign "C" barf("SRT_14 object (%p) entered!", R1) never returns; }
560
561 INFO_TABLE_CONSTR(stg_SRT_15, 15, 0, 0, CONSTR, "SRT_15", "SRT_15")
562 { foreign "C" barf("SRT_15 object (%p) entered!", R1) never returns; }
563
564 INFO_TABLE_CONSTR(stg_SRT_16, 16, 0, 0, CONSTR, "SRT_16", "SRT_16")
565 { foreign "C" barf("SRT_16 object (%p) entered!", R1) never returns; }
566
567 /* ---------------------------------------------------------------------------   Messages
568    ------------------------------------------------------------------------- */
569
570 // PRIM rather than CONSTR, because PRIM objects cannot be duplicated by the GC.
571
572 INFO_TABLE_CONSTR(stg_MSG_TRY_WAKEUP,2,0,0,PRIM,"MSG_TRY_WAKEUP","MSG_TRY_WAKEUP")
573 { foreign "C" barf("MSG_TRY_WAKEUP object (%p) entered!", R1) never returns; }
574
575 INFO_TABLE_CONSTR(stg_MSG_THROWTO,4,0,0,PRIM,"MSG_THROWTO","MSG_THROWTO")
576 { foreign "C" barf("MSG_THROWTO object (%p) entered!", R1) never returns; }
577
578 INFO_TABLE_CONSTR(stg_MSG_BLACKHOLE,3,0,0,PRIM,"MSG_BLACKHOLE","MSG_BLACKHOLE")
579 { foreign "C" barf("MSG_BLACKHOLE object (%p) entered!", R1) never returns; }
580
581 // used to overwrite a MSG_THROWTO when the message has been used/revoked
582 INFO_TABLE_CONSTR(stg_MSG_NULL,1,0,0,PRIM,"MSG_NULL","MSG_NULL")
583 { foreign "C" barf("MSG_NULL object (%p) entered!", R1) never returns; }
584
585 /* ----------------------------------------------------------------------------
586    END_TSO_QUEUE
587
588    This is a static nullary constructor (like []) that we use to mark the
589    end of a linked TSO queue.
590    ------------------------------------------------------------------------- */
591
592 INFO_TABLE_CONSTR(stg_END_TSO_QUEUE,0,0,0,CONSTR_NOCAF,"END_TSO_QUEUE","END_TSO_QUEUE")
593 { foreign "C" barf("END_TSO_QUEUE object (%p) entered!", R1) never returns; }
594
595 CLOSURE(stg_END_TSO_QUEUE_closure,stg_END_TSO_QUEUE);
596
597 /* ----------------------------------------------------------------------------
598    GCD_CAF
599    ------------------------------------------------------------------------- */
600
601 INFO_TABLE_CONSTR(stg_GCD_CAF,0,0,0,CONSTR_NOCAF,"GCD_CAF","GCD_CAF")
602 { foreign "C" barf("Evaluated a CAF (%p) that was GC'd!", R1) never returns; }
603
604 /* ----------------------------------------------------------------------------
605    STM_AWOKEN
606
607    This is a static nullary constructor (like []) that we use to mark a
608    thread waiting on an STM wakeup
609    ------------------------------------------------------------------------- */
610
611 INFO_TABLE_CONSTR(stg_STM_AWOKEN,0,0,0,CONSTR_NOCAF,"STM_AWOKEN","STM_AWOKEN")
612 { foreign "C" barf("STM_AWOKEN object (%p) entered!", R1) never returns; }
613
614 CLOSURE(stg_STM_AWOKEN_closure,stg_STM_AWOKEN);
615
616 /* ----------------------------------------------------------------------------
617    Arrays
618
619    These come in two basic flavours: arrays of data (StgArrWords) and arrays of
620    pointers (StgArrPtrs).  They all have a similar layout:
621
622    ___________________________
623    | Info | No. of | data....
624    |  Ptr | Words  |
625    ---------------------------
626
627    These are *unpointed* objects: i.e. they cannot be entered.
628
629    ------------------------------------------------------------------------- */
630
631 INFO_TABLE(stg_ARR_WORDS, 0, 0, ARR_WORDS, "ARR_WORDS", "ARR_WORDS")
632 { foreign "C" barf("ARR_WORDS object (%p) entered!", R1) never returns; }
633
634 INFO_TABLE(stg_MUT_ARR_PTRS_CLEAN, 0, 0, MUT_ARR_PTRS_CLEAN, "MUT_ARR_PTRS_CLEAN", "MUT_ARR_PTRS_CLEAN")
635 { foreign "C" barf("MUT_ARR_PTRS_CLEAN object (%p) entered!", R1) never returns; }
636
637 INFO_TABLE(stg_MUT_ARR_PTRS_DIRTY, 0, 0, MUT_ARR_PTRS_DIRTY, "MUT_ARR_PTRS_DIRTY", "MUT_ARR_PTRS_DIRTY")
638 { foreign "C" barf("MUT_ARR_PTRS_DIRTY object (%p) entered!", R1) never returns; }
639
640 INFO_TABLE(stg_MUT_ARR_PTRS_FROZEN_CLEAN, 0, 0, MUT_ARR_PTRS_FROZEN_CLEAN, "MUT_ARR_PTRS_FROZEN_CLEAN", "MUT_ARR_PTRS_FROZEN_CLEAN")
641 { foreign "C" barf("MUT_ARR_PTRS_FROZEN_CLEAN object (%p) entered!", R1) never returns; }
642
643 INFO_TABLE(stg_MUT_ARR_PTRS_FROZEN_DIRTY, 0, 0, MUT_ARR_PTRS_FROZEN_DIRTY, "MUT_ARR_PTRS_FROZEN_DIRTY", "MUT_ARR_PTRS_FROZEN_DIRTY")
644 { foreign "C" barf("MUT_ARR_PTRS_FROZEN_DIRTY object (%p) entered!", R1) never returns; }
645
646 INFO_TABLE(stg_SMALL_MUT_ARR_PTRS_CLEAN, 0, 0, SMALL_MUT_ARR_PTRS_CLEAN, "SMALL_MUT_ARR_PTRS_CLEAN", "SMALL_MUT_ARR_PTRS_CLEAN")
647 { foreign "C" barf("SMALL_MUT_ARR_PTRS_CLEAN object (%p) entered!", R1) never returns; }
648
649 INFO_TABLE(stg_SMALL_MUT_ARR_PTRS_DIRTY, 0, 0, SMALL_MUT_ARR_PTRS_DIRTY, "SMALL_MUT_ARR_PTRS_DIRTY", "SMALL_MUT_ARR_PTRS_DIRTY")
650 { foreign "C" barf("SMALL_MUT_ARR_PTRS_DIRTY object (%p) entered!", R1) never returns; }
651
652 INFO_TABLE(stg_SMALL_MUT_ARR_PTRS_FROZEN_CLEAN, 0, 0, SMALL_MUT_ARR_PTRS_FROZEN_CLEAN, "SMALL_MUT_ARR_PTRS_FROZEN_CLEAN", "SMALL_MUT_ARR_PTRS_FROZEN_CLEAN")
653 { foreign "C" barf("SMALL_MUT_ARR_PTRS_FROZEN_CLEAN object (%p) entered!", R1) never returns; }
654
655 INFO_TABLE(stg_SMALL_MUT_ARR_PTRS_FROZEN_DIRTY, 0, 0, SMALL_MUT_ARR_PTRS_FROZEN_DIRTY, "SMALL_MUT_ARR_PTRS_FROZEN_DIRTY", "SMALL_MUT_ARR_PTRS_FROZEN_DIRTY")
656 { foreign "C" barf("SMALL_MUT_ARR_PTRS_FROZEN_DIRTY object (%p) entered!", R1) never returns; }
657
658 /* ----------------------------------------------------------------------------
659    Mutable Variables
660    ------------------------------------------------------------------------- */
661
662 INFO_TABLE(stg_MUT_VAR_CLEAN, 1, 0, MUT_VAR_CLEAN, "MUT_VAR_CLEAN", "MUT_VAR_CLEAN")
663 { foreign "C" barf("MUT_VAR_CLEAN object (%p) entered!", R1) never returns; }
664 INFO_TABLE(stg_MUT_VAR_DIRTY, 1, 0, MUT_VAR_DIRTY, "MUT_VAR_DIRTY", "MUT_VAR_DIRTY")
665 { foreign "C" barf("MUT_VAR_DIRTY object (%p) entered!", R1) never returns; }
666
667 /* ----------------------------------------------------------------------------
668    Dummy return closure
669
670    Entering this closure will just return to the address on the top of the
671    stack.  Useful for getting a thread in a canonical form where we can
672    just enter the top stack word to start the thread.  (see deleteThread)
673  * ------------------------------------------------------------------------- */
674
675 INFO_TABLE( stg_dummy_ret, 0, 0, CONSTR_NOCAF, "DUMMY_RET", "DUMMY_RET")
676     ()
677 {
678     return ();
679 }
680 CLOSURE(stg_dummy_ret_closure,stg_dummy_ret);
681
682 /* ----------------------------------------------------------------------------
683    MVAR_TSO_QUEUE
684    ------------------------------------------------------------------------- */
685
686 INFO_TABLE_CONSTR(stg_MVAR_TSO_QUEUE,2,0,0,PRIM,"MVAR_TSO_QUEUE","MVAR_TSO_QUEUE")
687 { foreign "C" barf("MVAR_TSO_QUEUE object (%p) entered!", R1) never returns; }
688
689 /* ----------------------------------------------------------------------------
690    COMPACT_NFDATA (a blob of data in NF with no outgoing pointers)
691
692    See Note [Compact Normal Forms] in sm/CNF.c
693
694    CLEAN/DIRTY refer to the state of the "hash" field: DIRTY means that
695    compaction is in progress and the hash table needs to be scanned by the GC.
696    ------------------------------------------------------------------------- */
697
698 INFO_TABLE( stg_COMPACT_NFDATA_CLEAN, 0, 8, COMPACT_NFDATA, "COMPACT_NFDATA", "COMPACT_NFDATA")
699     ()
700 { foreign "C" barf("COMPACT_NFDATA_CLEAN object (%p) entered!", R1) never returns; }
701
702 INFO_TABLE( stg_COMPACT_NFDATA_DIRTY, 0, 8, COMPACT_NFDATA, "COMPACT_NFDATA", "COMPACT_NFDATA")
703     ()
704 { foreign "C" barf("COMPACT_NFDATA_DIRTY object (%p) entered!", R1) never returns; }
705
706 /* ----------------------------------------------------------------------------
707    CHARLIKE and INTLIKE closures.
708
709    These are static representations of Chars and small Ints, so that
710    we can remove dynamic Chars and Ints during garbage collection and
711    replace them with references to the static objects.
712    ------------------------------------------------------------------------- */
713
714 #if defined(COMPILING_WINDOWS_DLL)
715 /*
716  * When sticking the RTS in a Windows DLL, we delay populating the
717  * Charlike and Intlike tables until load-time, which is only
718  * when we've got the real addresses to the C# and I# closures.
719  *
720  * -- this is currently broken BL 2009/11/14.
721  *    we don't rewrite to static closures at all with Windows DLLs.
722  */
723 // #warning Is this correct? _imp is a pointer!
724 #define Char_hash_con_info _imp__ghczmprim_GHCziTypes_Czh_con_info
725 #define Int_hash_con_info _imp__ghczmprim_GHCziTypes_Izh_con_info
726 #else
727 #define Char_hash_con_info ghczmprim_GHCziTypes_Czh_con_info
728 #define Int_hash_con_info ghczmprim_GHCziTypes_Izh_con_info
729 #endif
730
731
732 #define CHARLIKE_HDR(n)  CLOSURE(Char_hash_con_info, n)
733 #define INTLIKE_HDR(n)   CLOSURE(Int_hash_con_info, n)
734
735 #if !(defined(COMPILING_WINDOWS_DLL))
736 section "data" {
737  stg_CHARLIKE_closure:
738     CHARLIKE_HDR(0)
739     CHARLIKE_HDR(1)
740     CHARLIKE_HDR(2)
741     CHARLIKE_HDR(3)
742     CHARLIKE_HDR(4)
743     CHARLIKE_HDR(5)
744     CHARLIKE_HDR(6)
745     CHARLIKE_HDR(7)
746     CHARLIKE_HDR(8)
747     CHARLIKE_HDR(9)
748     CHARLIKE_HDR(10)
749     CHARLIKE_HDR(11)
750     CHARLIKE_HDR(12)
751     CHARLIKE_HDR(13)
752     CHARLIKE_HDR(14)
753     CHARLIKE_HDR(15)
754     CHARLIKE_HDR(16)
755     CHARLIKE_HDR(17)
756     CHARLIKE_HDR(18)
757     CHARLIKE_HDR(19)
758     CHARLIKE_HDR(20)
759     CHARLIKE_HDR(21)
760     CHARLIKE_HDR(22)
761     CHARLIKE_HDR(23)
762     CHARLIKE_HDR(24)
763     CHARLIKE_HDR(25)
764     CHARLIKE_HDR(26)
765     CHARLIKE_HDR(27)
766     CHARLIKE_HDR(28)
767     CHARLIKE_HDR(29)
768     CHARLIKE_HDR(30)
769     CHARLIKE_HDR(31)
770     CHARLIKE_HDR(32)
771     CHARLIKE_HDR(33)
772     CHARLIKE_HDR(34)
773     CHARLIKE_HDR(35)
774     CHARLIKE_HDR(36)
775     CHARLIKE_HDR(37)
776     CHARLIKE_HDR(38)
777     CHARLIKE_HDR(39)
778     CHARLIKE_HDR(40)
779     CHARLIKE_HDR(41)
780     CHARLIKE_HDR(42)
781     CHARLIKE_HDR(43)
782     CHARLIKE_HDR(44)
783     CHARLIKE_HDR(45)
784     CHARLIKE_HDR(46)
785     CHARLIKE_HDR(47)
786     CHARLIKE_HDR(48)
787     CHARLIKE_HDR(49)
788     CHARLIKE_HDR(50)
789     CHARLIKE_HDR(51)
790     CHARLIKE_HDR(52)
791     CHARLIKE_HDR(53)
792     CHARLIKE_HDR(54)
793     CHARLIKE_HDR(55)
794     CHARLIKE_HDR(56)
795     CHARLIKE_HDR(57)
796     CHARLIKE_HDR(58)
797     CHARLIKE_HDR(59)
798     CHARLIKE_HDR(60)
799     CHARLIKE_HDR(61)
800     CHARLIKE_HDR(62)
801     CHARLIKE_HDR(63)
802     CHARLIKE_HDR(64)
803     CHARLIKE_HDR(65)
804     CHARLIKE_HDR(66)
805     CHARLIKE_HDR(67)
806     CHARLIKE_HDR(68)
807     CHARLIKE_HDR(69)
808     CHARLIKE_HDR(70)
809     CHARLIKE_HDR(71)
810     CHARLIKE_HDR(72)
811     CHARLIKE_HDR(73)
812     CHARLIKE_HDR(74)
813     CHARLIKE_HDR(75)
814     CHARLIKE_HDR(76)
815     CHARLIKE_HDR(77)
816     CHARLIKE_HDR(78)
817     CHARLIKE_HDR(79)
818     CHARLIKE_HDR(80)
819     CHARLIKE_HDR(81)
820     CHARLIKE_HDR(82)
821     CHARLIKE_HDR(83)
822     CHARLIKE_HDR(84)
823     CHARLIKE_HDR(85)
824     CHARLIKE_HDR(86)
825     CHARLIKE_HDR(87)
826     CHARLIKE_HDR(88)
827     CHARLIKE_HDR(89)
828     CHARLIKE_HDR(90)
829     CHARLIKE_HDR(91)
830     CHARLIKE_HDR(92)
831     CHARLIKE_HDR(93)
832     CHARLIKE_HDR(94)
833     CHARLIKE_HDR(95)
834     CHARLIKE_HDR(96)
835     CHARLIKE_HDR(97)
836     CHARLIKE_HDR(98)
837     CHARLIKE_HDR(99)
838     CHARLIKE_HDR(100)
839     CHARLIKE_HDR(101)
840     CHARLIKE_HDR(102)
841     CHARLIKE_HDR(103)
842     CHARLIKE_HDR(104)
843     CHARLIKE_HDR(105)
844     CHARLIKE_HDR(106)
845     CHARLIKE_HDR(107)
846     CHARLIKE_HDR(108)
847     CHARLIKE_HDR(109)
848     CHARLIKE_HDR(110)
849     CHARLIKE_HDR(111)
850     CHARLIKE_HDR(112)
851     CHARLIKE_HDR(113)
852     CHARLIKE_HDR(114)
853     CHARLIKE_HDR(115)
854     CHARLIKE_HDR(116)
855     CHARLIKE_HDR(117)
856     CHARLIKE_HDR(118)
857     CHARLIKE_HDR(119)
858     CHARLIKE_HDR(120)
859     CHARLIKE_HDR(121)
860     CHARLIKE_HDR(122)
861     CHARLIKE_HDR(123)
862     CHARLIKE_HDR(124)
863     CHARLIKE_HDR(125)
864     CHARLIKE_HDR(126)
865     CHARLIKE_HDR(127)
866     CHARLIKE_HDR(128)
867     CHARLIKE_HDR(129)
868     CHARLIKE_HDR(130)
869     CHARLIKE_HDR(131)
870     CHARLIKE_HDR(132)
871     CHARLIKE_HDR(133)
872     CHARLIKE_HDR(134)
873     CHARLIKE_HDR(135)
874     CHARLIKE_HDR(136)
875     CHARLIKE_HDR(137)
876     CHARLIKE_HDR(138)
877     CHARLIKE_HDR(139)
878     CHARLIKE_HDR(140)
879     CHARLIKE_HDR(141)
880     CHARLIKE_HDR(142)
881     CHARLIKE_HDR(143)
882     CHARLIKE_HDR(144)
883     CHARLIKE_HDR(145)
884     CHARLIKE_HDR(146)
885     CHARLIKE_HDR(147)
886     CHARLIKE_HDR(148)
887     CHARLIKE_HDR(149)
888     CHARLIKE_HDR(150)
889     CHARLIKE_HDR(151)
890     CHARLIKE_HDR(152)
891     CHARLIKE_HDR(153)
892     CHARLIKE_HDR(154)
893     CHARLIKE_HDR(155)
894     CHARLIKE_HDR(156)
895     CHARLIKE_HDR(157)
896     CHARLIKE_HDR(158)
897     CHARLIKE_HDR(159)
898     CHARLIKE_HDR(160)
899     CHARLIKE_HDR(161)
900     CHARLIKE_HDR(162)
901     CHARLIKE_HDR(163)
902     CHARLIKE_HDR(164)
903     CHARLIKE_HDR(165)
904     CHARLIKE_HDR(166)
905     CHARLIKE_HDR(167)
906     CHARLIKE_HDR(168)
907     CHARLIKE_HDR(169)
908     CHARLIKE_HDR(170)
909     CHARLIKE_HDR(171)
910     CHARLIKE_HDR(172)
911     CHARLIKE_HDR(173)
912     CHARLIKE_HDR(174)
913     CHARLIKE_HDR(175)
914     CHARLIKE_HDR(176)
915     CHARLIKE_HDR(177)
916     CHARLIKE_HDR(178)
917     CHARLIKE_HDR(179)
918     CHARLIKE_HDR(180)
919     CHARLIKE_HDR(181)
920     CHARLIKE_HDR(182)
921     CHARLIKE_HDR(183)
922     CHARLIKE_HDR(184)
923     CHARLIKE_HDR(185)
924     CHARLIKE_HDR(186)
925     CHARLIKE_HDR(187)
926     CHARLIKE_HDR(188)
927     CHARLIKE_HDR(189)
928     CHARLIKE_HDR(190)
929     CHARLIKE_HDR(191)
930     CHARLIKE_HDR(192)
931     CHARLIKE_HDR(193)
932     CHARLIKE_HDR(194)
933     CHARLIKE_HDR(195)
934     CHARLIKE_HDR(196)
935     CHARLIKE_HDR(197)
936     CHARLIKE_HDR(198)
937     CHARLIKE_HDR(199)
938     CHARLIKE_HDR(200)
939     CHARLIKE_HDR(201)
940     CHARLIKE_HDR(202)
941     CHARLIKE_HDR(203)
942     CHARLIKE_HDR(204)
943     CHARLIKE_HDR(205)
944     CHARLIKE_HDR(206)
945     CHARLIKE_HDR(207)
946     CHARLIKE_HDR(208)
947     CHARLIKE_HDR(209)
948     CHARLIKE_HDR(210)
949     CHARLIKE_HDR(211)
950     CHARLIKE_HDR(212)
951     CHARLIKE_HDR(213)
952     CHARLIKE_HDR(214)
953     CHARLIKE_HDR(215)
954     CHARLIKE_HDR(216)
955     CHARLIKE_HDR(217)
956     CHARLIKE_HDR(218)
957     CHARLIKE_HDR(219)
958     CHARLIKE_HDR(220)
959     CHARLIKE_HDR(221)
960     CHARLIKE_HDR(222)
961     CHARLIKE_HDR(223)
962     CHARLIKE_HDR(224)
963     CHARLIKE_HDR(225)
964     CHARLIKE_HDR(226)
965     CHARLIKE_HDR(227)
966     CHARLIKE_HDR(228)
967     CHARLIKE_HDR(229)
968     CHARLIKE_HDR(230)
969     CHARLIKE_HDR(231)
970     CHARLIKE_HDR(232)
971     CHARLIKE_HDR(233)
972     CHARLIKE_HDR(234)
973     CHARLIKE_HDR(235)
974     CHARLIKE_HDR(236)
975     CHARLIKE_HDR(237)
976     CHARLIKE_HDR(238)
977     CHARLIKE_HDR(239)
978     CHARLIKE_HDR(240)
979     CHARLIKE_HDR(241)
980     CHARLIKE_HDR(242)
981     CHARLIKE_HDR(243)
982     CHARLIKE_HDR(244)
983     CHARLIKE_HDR(245)
984     CHARLIKE_HDR(246)
985     CHARLIKE_HDR(247)
986     CHARLIKE_HDR(248)
987     CHARLIKE_HDR(249)
988     CHARLIKE_HDR(250)
989     CHARLIKE_HDR(251)
990     CHARLIKE_HDR(252)
991     CHARLIKE_HDR(253)
992     CHARLIKE_HDR(254)
993     CHARLIKE_HDR(255)
994 }
995
996 section "data" {
997  stg_INTLIKE_closure:
998     INTLIKE_HDR(-16) /* MIN_INTLIKE == -16 */
999     INTLIKE_HDR(-15)
1000     INTLIKE_HDR(-14)
1001     INTLIKE_HDR(-13)
1002     INTLIKE_HDR(-12)
1003     INTLIKE_HDR(-11)
1004     INTLIKE_HDR(-10)
1005     INTLIKE_HDR(-9)
1006     INTLIKE_HDR(-8)
1007     INTLIKE_HDR(-7)
1008     INTLIKE_HDR(-6)
1009     INTLIKE_HDR(-5)
1010     INTLIKE_HDR(-4)
1011     INTLIKE_HDR(-3)
1012     INTLIKE_HDR(-2)
1013     INTLIKE_HDR(-1)
1014     INTLIKE_HDR(0)
1015     INTLIKE_HDR(1)
1016     INTLIKE_HDR(2)
1017     INTLIKE_HDR(3)
1018     INTLIKE_HDR(4)
1019     INTLIKE_HDR(5)
1020     INTLIKE_HDR(6)
1021     INTLIKE_HDR(7)
1022     INTLIKE_HDR(8)
1023     INTLIKE_HDR(9)
1024     INTLIKE_HDR(10)
1025     INTLIKE_HDR(11)
1026     INTLIKE_HDR(12)
1027     INTLIKE_HDR(13)
1028     INTLIKE_HDR(14)
1029     INTLIKE_HDR(15)
1030     INTLIKE_HDR(16)
1031     INTLIKE_HDR(17)
1032     INTLIKE_HDR(18)
1033     INTLIKE_HDR(19)
1034     INTLIKE_HDR(20)
1035     INTLIKE_HDR(21)
1036     INTLIKE_HDR(22)
1037     INTLIKE_HDR(23)
1038     INTLIKE_HDR(24)
1039     INTLIKE_HDR(25)
1040     INTLIKE_HDR(26)
1041     INTLIKE_HDR(27)
1042     INTLIKE_HDR(28)
1043     INTLIKE_HDR(29)
1044     INTLIKE_HDR(30)
1045     INTLIKE_HDR(31)
1046     INTLIKE_HDR(32)
1047     INTLIKE_HDR(33)
1048     INTLIKE_HDR(34)
1049     INTLIKE_HDR(35)
1050     INTLIKE_HDR(36)
1051     INTLIKE_HDR(37)
1052     INTLIKE_HDR(38)
1053     INTLIKE_HDR(39)
1054     INTLIKE_HDR(40)
1055     INTLIKE_HDR(41)
1056     INTLIKE_HDR(42)
1057     INTLIKE_HDR(43)
1058     INTLIKE_HDR(44)
1059     INTLIKE_HDR(45)
1060     INTLIKE_HDR(46)
1061     INTLIKE_HDR(47)
1062     INTLIKE_HDR(48)
1063     INTLIKE_HDR(49)
1064     INTLIKE_HDR(50)
1065     INTLIKE_HDR(51)
1066     INTLIKE_HDR(52)
1067     INTLIKE_HDR(53)
1068     INTLIKE_HDR(54)
1069     INTLIKE_HDR(55)
1070     INTLIKE_HDR(56)
1071     INTLIKE_HDR(57)
1072     INTLIKE_HDR(58)
1073     INTLIKE_HDR(59)
1074     INTLIKE_HDR(60)
1075     INTLIKE_HDR(61)
1076     INTLIKE_HDR(62)
1077     INTLIKE_HDR(63)
1078     INTLIKE_HDR(64)
1079     INTLIKE_HDR(65)
1080     INTLIKE_HDR(66)
1081     INTLIKE_HDR(67)
1082     INTLIKE_HDR(68)
1083     INTLIKE_HDR(69)
1084     INTLIKE_HDR(70)
1085     INTLIKE_HDR(71)
1086     INTLIKE_HDR(72)
1087     INTLIKE_HDR(73)
1088     INTLIKE_HDR(74)
1089     INTLIKE_HDR(75)
1090     INTLIKE_HDR(76)
1091     INTLIKE_HDR(77)
1092     INTLIKE_HDR(78)
1093     INTLIKE_HDR(79)
1094     INTLIKE_HDR(80)
1095     INTLIKE_HDR(81)
1096     INTLIKE_HDR(82)
1097     INTLIKE_HDR(83)
1098     INTLIKE_HDR(84)
1099     INTLIKE_HDR(85)
1100     INTLIKE_HDR(86)
1101     INTLIKE_HDR(87)
1102     INTLIKE_HDR(88)
1103     INTLIKE_HDR(89)
1104     INTLIKE_HDR(90)
1105     INTLIKE_HDR(91)
1106     INTLIKE_HDR(92)
1107     INTLIKE_HDR(93)
1108     INTLIKE_HDR(94)
1109     INTLIKE_HDR(95)
1110     INTLIKE_HDR(96)
1111     INTLIKE_HDR(97)
1112     INTLIKE_HDR(98)
1113     INTLIKE_HDR(99)
1114     INTLIKE_HDR(100)
1115     INTLIKE_HDR(101)
1116     INTLIKE_HDR(102)
1117     INTLIKE_HDR(103)
1118     INTLIKE_HDR(104)
1119     INTLIKE_HDR(105)
1120     INTLIKE_HDR(106)
1121     INTLIKE_HDR(107)
1122     INTLIKE_HDR(108)
1123     INTLIKE_HDR(109)
1124     INTLIKE_HDR(110)
1125     INTLIKE_HDR(111)
1126     INTLIKE_HDR(112)
1127     INTLIKE_HDR(113)
1128     INTLIKE_HDR(114)
1129     INTLIKE_HDR(115)
1130     INTLIKE_HDR(116)
1131     INTLIKE_HDR(117)
1132     INTLIKE_HDR(118)
1133     INTLIKE_HDR(119)
1134     INTLIKE_HDR(120)
1135     INTLIKE_HDR(121)
1136     INTLIKE_HDR(122)
1137     INTLIKE_HDR(123)
1138     INTLIKE_HDR(124)
1139     INTLIKE_HDR(125)
1140     INTLIKE_HDR(126)
1141     INTLIKE_HDR(127)
1142     INTLIKE_HDR(128)
1143     INTLIKE_HDR(129)
1144     INTLIKE_HDR(130)
1145     INTLIKE_HDR(131)
1146     INTLIKE_HDR(132)
1147     INTLIKE_HDR(133)
1148     INTLIKE_HDR(134)
1149     INTLIKE_HDR(135)
1150     INTLIKE_HDR(136)
1151     INTLIKE_HDR(137)
1152     INTLIKE_HDR(138)
1153     INTLIKE_HDR(139)
1154     INTLIKE_HDR(140)
1155     INTLIKE_HDR(141)
1156     INTLIKE_HDR(142)
1157     INTLIKE_HDR(143)
1158     INTLIKE_HDR(144)
1159     INTLIKE_HDR(145)
1160     INTLIKE_HDR(146)
1161     INTLIKE_HDR(147)
1162     INTLIKE_HDR(148)
1163     INTLIKE_HDR(149)
1164     INTLIKE_HDR(150)
1165     INTLIKE_HDR(151)
1166     INTLIKE_HDR(152)
1167     INTLIKE_HDR(153)
1168     INTLIKE_HDR(154)
1169     INTLIKE_HDR(155)
1170     INTLIKE_HDR(156)
1171     INTLIKE_HDR(157)
1172     INTLIKE_HDR(158)
1173     INTLIKE_HDR(159)
1174     INTLIKE_HDR(160)
1175     INTLIKE_HDR(161)
1176     INTLIKE_HDR(162)
1177     INTLIKE_HDR(163)
1178     INTLIKE_HDR(164)
1179     INTLIKE_HDR(165)
1180     INTLIKE_HDR(166)
1181     INTLIKE_HDR(167)
1182     INTLIKE_HDR(168)
1183     INTLIKE_HDR(169)
1184     INTLIKE_HDR(170)
1185     INTLIKE_HDR(171)
1186     INTLIKE_HDR(172)
1187     INTLIKE_HDR(173)
1188     INTLIKE_HDR(174)
1189     INTLIKE_HDR(175)
1190     INTLIKE_HDR(176)
1191     INTLIKE_HDR(177)
1192     INTLIKE_HDR(178)
1193     INTLIKE_HDR(179)
1194     INTLIKE_HDR(180)
1195     INTLIKE_HDR(181)
1196     INTLIKE_HDR(182)
1197     INTLIKE_HDR(183)
1198     INTLIKE_HDR(184)
1199     INTLIKE_HDR(185)
1200     INTLIKE_HDR(186)
1201     INTLIKE_HDR(187)
1202     INTLIKE_HDR(188)
1203     INTLIKE_HDR(189)
1204     INTLIKE_HDR(190)
1205     INTLIKE_HDR(191)
1206     INTLIKE_HDR(192)
1207     INTLIKE_HDR(193)
1208     INTLIKE_HDR(194)
1209     INTLIKE_HDR(195)
1210     INTLIKE_HDR(196)
1211     INTLIKE_HDR(197)
1212     INTLIKE_HDR(198)
1213     INTLIKE_HDR(199)
1214     INTLIKE_HDR(200)
1215     INTLIKE_HDR(201)
1216     INTLIKE_HDR(202)
1217     INTLIKE_HDR(203)
1218     INTLIKE_HDR(204)
1219     INTLIKE_HDR(205)
1220     INTLIKE_HDR(206)
1221     INTLIKE_HDR(207)
1222     INTLIKE_HDR(208)
1223     INTLIKE_HDR(209)
1224     INTLIKE_HDR(210)
1225     INTLIKE_HDR(211)
1226     INTLIKE_HDR(212)
1227     INTLIKE_HDR(213)
1228     INTLIKE_HDR(214)
1229     INTLIKE_HDR(215)
1230     INTLIKE_HDR(216)
1231     INTLIKE_HDR(217)
1232     INTLIKE_HDR(218)
1233     INTLIKE_HDR(219)
1234     INTLIKE_HDR(220)
1235     INTLIKE_HDR(221)
1236     INTLIKE_HDR(222)
1237     INTLIKE_HDR(223)
1238     INTLIKE_HDR(224)
1239     INTLIKE_HDR(225)
1240     INTLIKE_HDR(226)
1241     INTLIKE_HDR(227)
1242     INTLIKE_HDR(228)
1243     INTLIKE_HDR(229)
1244     INTLIKE_HDR(230)
1245     INTLIKE_HDR(231)
1246     INTLIKE_HDR(232)
1247     INTLIKE_HDR(233)
1248     INTLIKE_HDR(234)
1249     INTLIKE_HDR(235)
1250     INTLIKE_HDR(236)
1251     INTLIKE_HDR(237)
1252     INTLIKE_HDR(238)
1253     INTLIKE_HDR(239)
1254     INTLIKE_HDR(240)
1255     INTLIKE_HDR(241)
1256     INTLIKE_HDR(242)
1257     INTLIKE_HDR(243)
1258     INTLIKE_HDR(244)
1259     INTLIKE_HDR(245)
1260     INTLIKE_HDR(246)
1261     INTLIKE_HDR(247)
1262     INTLIKE_HDR(248)
1263     INTLIKE_HDR(249)
1264     INTLIKE_HDR(250)
1265     INTLIKE_HDR(251)
1266     INTLIKE_HDR(252)
1267     INTLIKE_HDR(253)
1268     INTLIKE_HDR(254)
1269     INTLIKE_HDR(255)    /* MAX_INTLIKE == 255
1270                          See #16961 for why 255 */
1271 }
1272
1273 #endif