[pcsx_rearmed.git] / deps / lightning / lib / jit_print.c

/*
 * Copyright (C) 2012-2019  Free Software Foundation, Inc.
 *
 * This file is part of GNU lightning.
 *
 * GNU lightning is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 *
 * GNU lightning is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * Authors:
 *	Paulo Cesar Pereira de Andrade
 */

#include <lightning.h>
#include <lightning/jit_private.h>

#define print_chr(value)		fputc(value, print_stream)
#define print_hex(value)		fprintf(print_stream, "0x%lx", value)
#define print_dec(value)		fprintf(print_stream, "%ld", value)
#define print_flt(value)		fprintf(print_stream, "%g", value)
#define print_str(value)		fprintf(print_stream, "%s", value)
#define print_ptr(value)		fprintf(print_stream, "%p", value)
#define print_reg(value)						\
    do {								\
	if ((value) & jit_regno_patch)					\
	    print_chr('?');						\
	print_str(_rvs[jit_regno(value)].name);				\
    } while (0)
#define print_arg(value)						\
    do {								\
	print_chr('#');							\
	if (value)							\
	    print_dec((value)->v.w);					\
	else								\
	    print_chr('?');						\
    } while (0)

/*
 * Initialization
 */
#include "jit_names.c"
/*
 * Initialization
 */
static FILE	*print_stream;


/*
 * Implementation
 */
void
jit_init_print(void)
{
    if (!print_stream)
	print_stream = stderr;
}

void
_jit_print(jit_state_t *_jit)
{
    jit_node_t		*node;

    if ((node = _jitc->head)) {
	jit_print_node(node);
	for (node = node->next; node; node = node->next) {
	    print_chr('\n');
	    jit_print_node(node);
	}
	print_chr('\n');
    }
}

void
_jit_print_node(jit_state_t *_jit, jit_node_t *node)
{
    jit_block_t		*block;
    jit_int32_t		 value;
    jit_int32_t		 offset;

    if (node->code == jit_code_label ||
	node->code == jit_code_prolog || node->code == jit_code_epilog) {
	print_chr('L');
	print_dec(node->v.w);
	print_chr(':');
	block = _jitc->blocks.ptr + node->v.w;
	for (offset = 0; offset < _jitc->reglen; offset++) {
	    if (jit_regset_tstbit(&block->reglive, offset)) {
		print_chr(' ');
		print_reg(offset);
	    }
	}
	if (node->code == jit_code_prolog ||
	    node->code == jit_code_epilog) {
	    print_str(" /* ");
	    print_str(code_name[node->code]);
	    print_str(" */");
	}
	return;
    }
    value = jit_classify(node->code) &
	(jit_cc_a0_int|jit_cc_a0_flt|jit_cc_a0_dbl|jit_cc_a0_jmp|
	 jit_cc_a0_reg|jit_cc_a0_rlh|jit_cc_a0_arg|
	 jit_cc_a1_reg|jit_cc_a1_int|jit_cc_a1_flt|jit_cc_a1_dbl|jit_cc_a1_arg|
	 jit_cc_a2_reg|jit_cc_a2_int|jit_cc_a2_flt|jit_cc_a2_dbl);
    if (!(node->flag & jit_flag_synth) && ((value & jit_cc_a0_jmp) ||
					   node->code == jit_code_finishr ||
					   node->code == jit_code_finishi))
	print_str("    ");
    else
	print_chr('\t');
    if (node->flag & jit_flag_synth)
	print_str(" \\__ ");
    print_str(code_name[node->code]);
    switch (node->code) {
	r:
	    print_chr(' ');	print_reg(node->u.w);	return;
	w:
	    print_chr(' ');	print_hex(node->u.w);	return;
	f:
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float32_t *)node->u.n->u.w);
	    else
		print_flt(node->u.f);
	    return;
	d:
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float64_t *)node->u.n->u.w);
	    else
		print_flt(node->u.d);
	    return;
	n:
	    print_chr(' ');
	    if (!(node->flag & jit_flag_node))
		print_ptr(node->u.p);
	    else {
		print_chr('L');
		print_dec(node->u.n->v.w);
	    }
	    return;
	a:
	    print_chr(' ');	print_arg(node);	return;
	r_r:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');	print_reg(node->v.w);	return;
	r_w:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');	print_hex(node->v.w);	return;
	r_f:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float32_t *)node->v.n->u.w);
	    else
		print_flt(node->v.f);
	    return;
	r_d:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float64_t *)node->v.n->u.w);
	    else
		print_flt(node->v.d);
	    return;
	r_a:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');	print_arg(node->v.n);
	    return;
	w_r:
	    print_chr(' ');	print_hex(node->u.w);
	    print_chr(' ');	print_reg(node->v.w);   return;
	w_w:
	    print_chr(' ');	print_hex(node->u.w);
	    print_chr(' ');	print_hex(node->v.w);   return;
	w_a:
	    print_chr(' ');	print_hex(node->u.w);
	    print_chr(' ');	print_arg(node->v.n);
	    return;
	f_a:
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float32_t *)node->u.n->u.w);
	    else
		print_flt(node->u.f);
	    print_chr(' ');	print_arg(node->v.n);
	    return;
	d_a:
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float64_t *)node->u.n->u.w);
	    else
		print_flt(node->u.d);
	    print_chr(' ');	print_arg(node->v.n);
	    return;
	r_r_r:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');	print_reg(node->w.w);   return;
	r_r_w:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');	print_hex(node->w.w);   return;
	q_r_r:
	    print_str(" (");	print_reg(node->u.q.l);
	    print_chr(' ');	print_reg(node->u.q.h);
	    print_str(") ");	print_reg(node->v.w);
	    print_chr(' ');	print_reg(node->w.w);   return;
	q_r_w:
	    print_str(" (");	print_reg(node->u.q.l);
	    print_chr(' ');	print_reg(node->u.q.h);
	    print_str(") ");	print_reg(node->v.w);
	    print_chr(' ');	print_hex(node->w.w);   return;
	r_r_f:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float32_t *)node->w.n->u.w);
	    else
		print_flt(node->w.f);
	    return;
	r_r_d:
	    print_chr(' ');	print_reg(node->u.w);
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float64_t *)node->w.n->u.w);
	    else
		print_flt(node->w.d);
	    return;
	w_r_r:
	    print_chr(' ');	print_hex(node->u.w);
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');	print_reg(node->w.w);   return;
	n_r_r:
	    print_chr(' ');
	    if (!(node->flag & jit_flag_node))
		print_ptr(node->u.p);
	    else {
		print_chr('L');
		print_dec(node->u.n->v.w);
	    }
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');	print_reg(node->w.w);   return;
	n_r_w:
	    print_chr(' ');
	    if (!(node->flag & jit_flag_node))
		print_ptr(node->u.p);
	    else {
		print_chr('L');
		print_dec(node->u.n->v.w);
	    }
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');	print_hex(node->w.w);   return;
	n_r_f:
	    print_chr(' ');
	    if (!(node->flag & jit_flag_node))
		print_ptr(node->u.p);
	    else{
		print_chr('L');
		print_dec(node->u.n->v.w);
	    }
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float32_t *)node->w.n->u.w);
	    else
		print_flt(node->w.f);
	    return;
	n_r_d:
	    print_chr(' ');
	    if (!(node->flag & jit_flag_node))
		print_ptr(node->u.p);
	    else {
		print_chr('L');
		print_dec(node->u.n->v.w);
	    }
	    print_chr(' ');	print_reg(node->v.w);
	    print_chr(' ');
	    if (node->flag & jit_flag_data)
		print_flt(*(jit_float64_t *)node->w.n->u.w);
	    else
		print_flt(node->w.d);
	    return;
	case jit_code_name:
	    print_chr(' ');
	    if (node->v.p && _jitc->emit)
		print_str(node->v.n->u.p);
	    break;
	case jit_code_note:
	    print_chr(' ');
	    if (node->v.p && _jitc->emit)
		print_str(node->v.n->u.p);
	    if (node->v.p && _jitc->emit && node->w.w)
		print_chr(':');
	    if (node->w.w)
		print_dec(node->w.w);
	    break;
	case jit_code_data:
	case jit_code_label:
	case jit_code_ellipsis:
	case jit_code_prolog:	case jit_code_epilog:
	case jit_code_ret:	case jit_code_prepare:
	    break;
	case jit_code_save:	case jit_code_load:
	    goto r;
	default:
	    switch (value) {
		case jit_cc_a0_reg:
		case jit_cc_a0_reg|jit_cc_a0_chg:
		case jit_cc_a0_reg|jit_cc_a0_jmp:
		    goto r;
		case jit_cc_a0_int:
		    goto w;
		case jit_cc_a0_flt:
		    goto f;
		case jit_cc_a0_dbl:
		    goto d;
		case jit_cc_a0_jmp:
		    goto n;
		case jit_cc_a0_int|jit_cc_a0_arg:
		    goto a;
		case jit_cc_a0_reg|jit_cc_a1_reg:
		    goto r_r;
		case jit_cc_a0_reg|jit_cc_a1_int:
		    goto r_w;
		case jit_cc_a0_reg|jit_cc_a1_flt:
		    goto r_f;
		case jit_cc_a0_reg|jit_cc_a1_dbl:
		    goto r_d;
		case jit_cc_a0_reg|jit_cc_a1_arg:
		    goto r_a;
		case jit_cc_a0_int|jit_cc_a1_reg:
		    goto w_r;
		case jit_cc_a0_int|jit_cc_a1_int:
		    goto w_w;
		case jit_cc_a0_int|jit_cc_a1_arg:
		    goto w_a;
		case jit_cc_a0_flt|jit_cc_a1_arg:
		    goto f_a;
		case jit_cc_a0_dbl|jit_cc_a1_arg:
		    goto d_a;
		case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_reg:
		    goto r_r_r;
		case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_int:
		    goto r_r_w;
		case jit_cc_a0_reg|jit_cc_a0_rlh|
		     jit_cc_a1_reg|jit_cc_a2_reg:
		    goto q_r_r;
		case jit_cc_a0_reg|jit_cc_a0_rlh|
		     jit_cc_a1_reg|jit_cc_a2_int:
		    goto q_r_w;
		case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_flt:
		    goto r_r_f;
		case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_dbl:
		    goto r_r_d;
		case jit_cc_a0_int|jit_cc_a1_reg|jit_cc_a2_reg:
		    goto w_r_r;
		case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_reg:
		    goto n_r_r;
		case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_int:
		    goto n_r_w;
		case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_flt:
		    goto n_r_f;
		case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_dbl:
		    goto n_r_d;
		default:
		    abort();
	    }
	    break;
    }
}
Commit	Line	Data
4a71579b PC	1	/*
	2	* Copyright (C) 2012-2019 Free Software Foundation, Inc.
	3	*
	4	* This file is part of GNU lightning.
	5	*
	6	* GNU lightning is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU Lesser General Public License as published
	8	* by the Free Software Foundation; either version 3, or (at your option)
	9	* any later version.
	10	*
	11	* GNU lightning is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	13	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
	14	* License for more details.
	15	*
	16	* Authors:
	17	* Paulo Cesar Pereira de Andrade
	18	*/
	19
	20	#include <lightning.h>
	21	#include <lightning/jit_private.h>
	22
519a9ea1 PC	23	#define print_chr(value) fputc(value, print_stream)
	24	#define print_hex(value) fprintf(print_stream, "0x%lx", value)
	25	#define print_dec(value) fprintf(print_stream, "%ld", value)
	26	#define print_flt(value) fprintf(print_stream, "%g", value)
	27	#define print_str(value) fprintf(print_stream, "%s", value)
	28	#define print_ptr(value) fprintf(print_stream, "%p", value)
4a71579b PC	29	#define print_reg(value) \
	30	do { \
	31	if ((value) & jit_regno_patch) \
	32	print_chr('?'); \
	33	print_str(_rvs[jit_regno(value)].name); \
	34	} while (0)
	35	#define print_arg(value) \
	36	do { \
	37	print_chr('#'); \
	38	if (value) \
	39	print_dec((value)->v.w); \
	40	else \
	41	print_chr('?'); \
	42	} while (0)
	43
	44	/*
	45	* Initialization
	46	*/
	47	#include "jit_names.c"
519a9ea1 PC	48	/*
	49	* Initialization
	50	*/
	51	static FILE *print_stream;
	52
4a71579b PC	53
	54	/*
	55	* Implementation
	56	*/
	57	void
40a44dcb	58	jit_init_print(void)
4a71579b	59	{
519a9ea1 PC	60	if (!print_stream)
519a9ea1 PC	61	print_stream = stderr;
40a44dcb PC	62	}
	63
	64	void
	65	_jit_print(jit_state_t *_jit)
	66	{
	67	jit_node_t *node;
519a9ea1	68
4a71579b PC	69	if ((node = _jitc->head)) {
	70	jit_print_node(node);
	71	for (node = node->next; node; node = node->next) {
	72	print_chr('\n');
	73	jit_print_node(node);
	74	}
	75	print_chr('\n');
	76	}
	77	}
	78
	79	void
	80	_jit_print_node(jit_state_t _jit, jit_node_t node)
	81	{
	82	jit_block_t *block;
	83	jit_int32_t value;
	84	jit_int32_t offset;
	85
	86	if (node->code == jit_code_label \|\|
	87	node->code == jit_code_prolog \|\| node->code == jit_code_epilog) {
	88	print_chr('L');
	89	print_dec(node->v.w);
	90	print_chr(':');
	91	block = _jitc->blocks.ptr + node->v.w;
	92	for (offset = 0; offset < _jitc->reglen; offset++) {
	93	if (jit_regset_tstbit(&block->reglive, offset)) {
	94	print_chr(' ');
	95	print_reg(offset);
	96	}
	97	}
	98	if (node->code == jit_code_prolog \|\|
	99	node->code == jit_code_epilog) {
	100	print_str(" /* ");
	101	print_str(code_name[node->code]);
	102	print_str(" */");
	103	}
	104	return;
	105	}
	106	value = jit_classify(node->code) &
	107	(jit_cc_a0_int\|jit_cc_a0_flt\|jit_cc_a0_dbl\|jit_cc_a0_jmp\|
	108	jit_cc_a0_reg\|jit_cc_a0_rlh\|jit_cc_a0_arg\|
	109	jit_cc_a1_reg\|jit_cc_a1_int\|jit_cc_a1_flt\|jit_cc_a1_dbl\|jit_cc_a1_arg\|
	110	jit_cc_a2_reg\|jit_cc_a2_int\|jit_cc_a2_flt\|jit_cc_a2_dbl);
	111	if (!(node->flag & jit_flag_synth) && ((value & jit_cc_a0_jmp) \|\|
	112	node->code == jit_code_finishr \|\|
	113	node->code == jit_code_finishi))
	114	print_str(" ");
	115	else
	116	print_chr('\t');
	117	if (node->flag & jit_flag_synth)
	118	print_str(" \\__ ");
	119	print_str(code_name[node->code]);
	120	switch (node->code) {
	121	r:
	122	print_chr(' '); print_reg(node->u.w); return;
	123	w:
	124	print_chr(' '); print_hex(node->u.w); return;
	125	f:
	126	print_chr(' ');
	127	if (node->flag & jit_flag_data)
	128	print_flt((jit_float32_t )node->u.n->u.w);
	129	else
	130	print_flt(node->u.f);
	131	return;
	132	d:
133	print_chr(' ');
134	if (node->flag & jit_flag_data)
135	print_flt((jit_float64_t )node->u.n->u.w);
136	else
137	print_flt(node->u.d);
138	return;
139	n:
140	print_chr(' ');
141	if (!(node->flag & jit_flag_node))
142	print_ptr(node->u.p);
143	else {
144	print_chr('L');
145	print_dec(node->u.n->v.w);
146	}
147	return;
148	a:
149	print_chr(' '); print_arg(node); return;
150	r_r:
151	print_chr(' '); print_reg(node->u.w);
152	print_chr(' '); print_reg(node->v.w); return;
153	r_w:
154	print_chr(' '); print_reg(node->u.w);
155	print_chr(' '); print_hex(node->v.w); return;
156	r_f:
157	print_chr(' '); print_reg(node->u.w);
158	print_chr(' ');
159	if (node->flag & jit_flag_data)
160	print_flt((jit_float32_t )node->v.n->u.w);
161	else
162	print_flt(node->v.f);
163	return;
164	r_d:
165	print_chr(' '); print_reg(node->u.w);
166	print_chr(' ');
167	if (node->flag & jit_flag_data)
168	print_flt((jit_float64_t )node->v.n->u.w);
169	else
170	print_flt(node->v.d);
171	return;
172	r_a:
173	print_chr(' '); print_reg(node->u.w);
174	print_chr(' '); print_arg(node->v.n);
175	return;
176	w_r:
177	print_chr(' '); print_hex(node->u.w);
178	print_chr(' '); print_reg(node->v.w); return;
179	w_w:
180	print_chr(' '); print_hex(node->u.w);
181	print_chr(' '); print_hex(node->v.w); return;
182	w_a:
183	print_chr(' '); print_hex(node->u.w);
184	print_chr(' '); print_arg(node->v.n);
185	return;
186	f_a:
187	print_chr(' ');
188	if (node->flag & jit_flag_data)
189	print_flt((jit_float32_t )node->u.n->u.w);
190	else
191	print_flt(node->u.f);
192	print_chr(' '); print_arg(node->v.n);
193	return;
194	d_a:
195	print_chr(' ');
196	if (node->flag & jit_flag_data)
197	print_flt((jit_float64_t )node->u.n->u.w);
198	else
199	print_flt(node->u.d);
200	print_chr(' '); print_arg(node->v.n);
201	return;
202	r_r_r:
203	print_chr(' '); print_reg(node->u.w);
204	print_chr(' '); print_reg(node->v.w);
205	print_chr(' '); print_reg(node->w.w); return;
206	r_r_w:
207	print_chr(' '); print_reg(node->u.w);
208	print_chr(' '); print_reg(node->v.w);
209	print_chr(' '); print_hex(node->w.w); return;
210	q_r_r:
211	print_str(" ("); print_reg(node->u.q.l);
212	print_chr(' '); print_reg(node->u.q.h);
213	print_str(") "); print_reg(node->v.w);
214	print_chr(' '); print_reg(node->w.w); return;
215	q_r_w:
216	print_str(" ("); print_reg(node->u.q.l);
217	print_chr(' '); print_reg(node->u.q.h);
218	print_str(") "); print_reg(node->v.w);
219	print_chr(' '); print_hex(node->w.w); return;
220	r_r_f:
221	print_chr(' '); print_reg(node->u.w);
222	print_chr(' '); print_reg(node->v.w);
223	print_chr(' ');
224	if (node->flag & jit_flag_data)
225	print_flt((jit_float32_t )node->w.n->u.w);
226	else
227	print_flt(node->w.f);
228	return;
229	r_r_d:
230	print_chr(' '); print_reg(node->u.w);
231	print_chr(' '); print_reg(node->v.w);
232	print_chr(' ');
233	if (node->flag & jit_flag_data)
234	print_flt((jit_float64_t )node->w.n->u.w);
235	else
236	print_flt(node->w.d);
237	return;
238	w_r_r:
239	print_chr(' '); print_hex(node->u.w);
240	print_chr(' '); print_reg(node->v.w);
241	print_chr(' '); print_reg(node->w.w); return;
242	n_r_r:
243	print_chr(' ');
244	if (!(node->flag & jit_flag_node))
245	print_ptr(node->u.p);
246	else {
247	print_chr('L');
248	print_dec(node->u.n->v.w);
249	}
250	print_chr(' '); print_reg(node->v.w);
251	print_chr(' '); print_reg(node->w.w); return;
252	n_r_w:
253	print_chr(' ');
254	if (!(node->flag & jit_flag_node))
255	print_ptr(node->u.p);
256	else {
257	print_chr('L');
258	print_dec(node->u.n->v.w);
259	}
260	print_chr(' '); print_reg(node->v.w);
261	print_chr(' '); print_hex(node->w.w); return;
262	n_r_f:
263	print_chr(' ');
264	if (!(node->flag & jit_flag_node))
265	print_ptr(node->u.p);
266	else{
267	print_chr('L');
268	print_dec(node->u.n->v.w);
269	}
270	print_chr(' '); print_reg(node->v.w);
271	print_chr(' ');
272	if (node->flag & jit_flag_data)
273	print_flt((jit_float32_t )node->w.n->u.w);
274	else
275	print_flt(node->w.f);
276	return;
277	n_r_d:
278	print_chr(' ');
279	if (!(node->flag & jit_flag_node))
280	print_ptr(node->u.p);
281	else {
282	print_chr('L');
283	print_dec(node->u.n->v.w);
284	}
285	print_chr(' '); print_reg(node->v.w);
286	print_chr(' ');
287	if (node->flag & jit_flag_data)
288	print_flt((jit_float64_t )node->w.n->u.w);
289	else
290	print_flt(node->w.d);
291	return;
292	case jit_code_name:
293	print_chr(' ');
294	if (node->v.p && _jitc->emit)
519a9ea1	295	print_str(node->v.n->u.p);
4a71579b PC	296	break;
	297	case jit_code_note:
	298	print_chr(' ');
	299	if (node->v.p && _jitc->emit)
519a9ea1	300	print_str(node->v.n->u.p);
4a71579b PC	301	if (node->v.p && _jitc->emit && node->w.w)
	302	print_chr(':');
	303	if (node->w.w)
	304	print_dec(node->w.w);
	305	break;
	306	case jit_code_data:
	307	case jit_code_label:
	308	case jit_code_ellipsis:
	309	case jit_code_prolog: case jit_code_epilog:
	310	case jit_code_ret: case jit_code_prepare:
	311	break;
	312	case jit_code_save: case jit_code_load:
	313	goto r;
	314	default:
	315	switch (value) {
	316	case jit_cc_a0_reg:
	317	case jit_cc_a0_reg\|jit_cc_a0_chg:
	318	case jit_cc_a0_reg\|jit_cc_a0_jmp:
	319	goto r;
	320	case jit_cc_a0_int:
	321	goto w;
	322	case jit_cc_a0_flt:
	323	goto f;
	324	case jit_cc_a0_dbl:
	325	goto d;
	326	case jit_cc_a0_jmp:
	327	goto n;
	328	case jit_cc_a0_int\|jit_cc_a0_arg:
	329	goto a;
	330	case jit_cc_a0_reg\|jit_cc_a1_reg:
	331	goto r_r;
	332	case jit_cc_a0_reg\|jit_cc_a1_int:
	333	goto r_w;
	334	case jit_cc_a0_reg\|jit_cc_a1_flt:
	335	goto r_f;
	336	case jit_cc_a0_reg\|jit_cc_a1_dbl:
	337	goto r_d;
	338	case jit_cc_a0_reg\|jit_cc_a1_arg:
	339	goto r_a;
	340	case jit_cc_a0_int\|jit_cc_a1_reg:
	341	goto w_r;
	342	case jit_cc_a0_int\|jit_cc_a1_int:
	343	goto w_w;
	344	case jit_cc_a0_int\|jit_cc_a1_arg:
	345	goto w_a;
	346	case jit_cc_a0_flt\|jit_cc_a1_arg:
	347	goto f_a;
	348	case jit_cc_a0_dbl\|jit_cc_a1_arg:
	349	goto d_a;
	350	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_reg:
	351	goto r_r_r;
	352	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_int:
	353	goto r_r_w;
	354	case jit_cc_a0_reg\|jit_cc_a0_rlh\|
	355	jit_cc_a1_reg\|jit_cc_a2_reg:
	356	goto q_r_r;
	357	case jit_cc_a0_reg\|jit_cc_a0_rlh\|
	358	jit_cc_a1_reg\|jit_cc_a2_int:
	359	goto q_r_w;
	360	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_flt:
	361	goto r_r_f;
	362	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_dbl:
	363	goto r_r_d;
	364	case jit_cc_a0_int\|jit_cc_a1_reg\|jit_cc_a2_reg:
365	goto w_r_r;
366	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_reg:
367	goto n_r_r;
368	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_int:
369	goto n_r_w;
370	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_flt:
371	goto n_r_f;
372	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_dbl:
373	goto n_r_d;
374	default:
375	abort();
376	}
377	break;
378	}
379	}