[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_print(jit_state_t *_jit)
{
    jit_node_t		*node;

    if (!print_stream)
	print_stream = stderr;

    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
	58	_jit_print(jit_state_t *_jit)
	59	{
	60	jit_node_t *node;
	61
519a9ea1 PC	62	if (!print_stream)
	63	print_stream = stderr;
	64
4a71579b PC	65	if ((node = _jitc->head)) {
	66	jit_print_node(node);
	67	for (node = node->next; node; node = node->next) {
	68	print_chr('\n');
	69	jit_print_node(node);
	70	}
	71	print_chr('\n');
	72	}
	73	}
	74
	75	void
	76	_jit_print_node(jit_state_t _jit, jit_node_t node)
	77	{
	78	jit_block_t *block;
	79	jit_int32_t value;
	80	jit_int32_t offset;
	81
	82	if (node->code == jit_code_label \|\|
	83	node->code == jit_code_prolog \|\| node->code == jit_code_epilog) {
	84	print_chr('L');
	85	print_dec(node->v.w);
	86	print_chr(':');
	87	block = _jitc->blocks.ptr + node->v.w;
	88	for (offset = 0; offset < _jitc->reglen; offset++) {
	89	if (jit_regset_tstbit(&block->reglive, offset)) {
	90	print_chr(' ');
	91	print_reg(offset);
	92	}
	93	}
	94	if (node->code == jit_code_prolog \|\|
	95	node->code == jit_code_epilog) {
	96	print_str(" /* ");
	97	print_str(code_name[node->code]);
	98	print_str(" */");
	99	}
	100	return;
	101	}
	102	value = jit_classify(node->code) &
	103	(jit_cc_a0_int\|jit_cc_a0_flt\|jit_cc_a0_dbl\|jit_cc_a0_jmp\|
	104	jit_cc_a0_reg\|jit_cc_a0_rlh\|jit_cc_a0_arg\|
	105	jit_cc_a1_reg\|jit_cc_a1_int\|jit_cc_a1_flt\|jit_cc_a1_dbl\|jit_cc_a1_arg\|
	106	jit_cc_a2_reg\|jit_cc_a2_int\|jit_cc_a2_flt\|jit_cc_a2_dbl);
	107	if (!(node->flag & jit_flag_synth) && ((value & jit_cc_a0_jmp) \|\|
	108	node->code == jit_code_finishr \|\|
	109	node->code == jit_code_finishi))
	110	print_str(" ");
	111	else
	112	print_chr('\t');
	113	if (node->flag & jit_flag_synth)
	114	print_str(" \\__ ");
	115	print_str(code_name[node->code]);
	116	switch (node->code) {
	117	r:
	118	print_chr(' '); print_reg(node->u.w); return;
	119	w:
	120	print_chr(' '); print_hex(node->u.w); return;
	121	f:
	122	print_chr(' ');
	123	if (node->flag & jit_flag_data)
	124	print_flt((jit_float32_t )node->u.n->u.w);
	125	else
	126	print_flt(node->u.f);
	127	return;
	128	d:
129	print_chr(' ');
130	if (node->flag & jit_flag_data)
131	print_flt((jit_float64_t )node->u.n->u.w);
132	else
133	print_flt(node->u.d);
134	return;
135	n:
136	print_chr(' ');
137	if (!(node->flag & jit_flag_node))
138	print_ptr(node->u.p);
139	else {
140	print_chr('L');
141	print_dec(node->u.n->v.w);
142	}
143	return;
144	a:
145	print_chr(' '); print_arg(node); return;
146	r_r:
147	print_chr(' '); print_reg(node->u.w);
148	print_chr(' '); print_reg(node->v.w); return;
149	r_w:
150	print_chr(' '); print_reg(node->u.w);
151	print_chr(' '); print_hex(node->v.w); return;
152	r_f:
153	print_chr(' '); print_reg(node->u.w);
154	print_chr(' ');
155	if (node->flag & jit_flag_data)
156	print_flt((jit_float32_t )node->v.n->u.w);
157	else
158	print_flt(node->v.f);
159	return;
160	r_d:
161	print_chr(' '); print_reg(node->u.w);
162	print_chr(' ');
163	if (node->flag & jit_flag_data)
164	print_flt((jit_float64_t )node->v.n->u.w);
165	else
166	print_flt(node->v.d);
167	return;
168	r_a:
169	print_chr(' '); print_reg(node->u.w);
170	print_chr(' '); print_arg(node->v.n);
171	return;
172	w_r:
173	print_chr(' '); print_hex(node->u.w);
174	print_chr(' '); print_reg(node->v.w); return;
175	w_w:
176	print_chr(' '); print_hex(node->u.w);
177	print_chr(' '); print_hex(node->v.w); return;
178	w_a:
179	print_chr(' '); print_hex(node->u.w);
180	print_chr(' '); print_arg(node->v.n);
181	return;
182	f_a:
183	print_chr(' ');
184	if (node->flag & jit_flag_data)
185	print_flt((jit_float32_t )node->u.n->u.w);
186	else
187	print_flt(node->u.f);
188	print_chr(' '); print_arg(node->v.n);
189	return;
190	d_a:
191	print_chr(' ');
192	if (node->flag & jit_flag_data)
193	print_flt((jit_float64_t )node->u.n->u.w);
194	else
195	print_flt(node->u.d);
196	print_chr(' '); print_arg(node->v.n);
197	return;
198	r_r_r:
199	print_chr(' '); print_reg(node->u.w);
200	print_chr(' '); print_reg(node->v.w);
201	print_chr(' '); print_reg(node->w.w); return;
202	r_r_w:
203	print_chr(' '); print_reg(node->u.w);
204	print_chr(' '); print_reg(node->v.w);
205	print_chr(' '); print_hex(node->w.w); return;
206	q_r_r:
207	print_str(" ("); print_reg(node->u.q.l);
208	print_chr(' '); print_reg(node->u.q.h);
209	print_str(") "); print_reg(node->v.w);
210	print_chr(' '); print_reg(node->w.w); return;
211	q_r_w:
212	print_str(" ("); print_reg(node->u.q.l);
213	print_chr(' '); print_reg(node->u.q.h);
214	print_str(") "); print_reg(node->v.w);
215	print_chr(' '); print_hex(node->w.w); return;
216	r_r_f:
217	print_chr(' '); print_reg(node->u.w);
218	print_chr(' '); print_reg(node->v.w);
219	print_chr(' ');
220	if (node->flag & jit_flag_data)
221	print_flt((jit_float32_t )node->w.n->u.w);
222	else
223	print_flt(node->w.f);
224	return;
225	r_r_d:
226	print_chr(' '); print_reg(node->u.w);
227	print_chr(' '); print_reg(node->v.w);
228	print_chr(' ');
229	if (node->flag & jit_flag_data)
230	print_flt((jit_float64_t )node->w.n->u.w);
231	else
232	print_flt(node->w.d);
233	return;
234	w_r_r:
235	print_chr(' '); print_hex(node->u.w);
236	print_chr(' '); print_reg(node->v.w);
237	print_chr(' '); print_reg(node->w.w); return;
238	n_r_r:
239	print_chr(' ');
240	if (!(node->flag & jit_flag_node))
241	print_ptr(node->u.p);
242	else {
243	print_chr('L');
244	print_dec(node->u.n->v.w);
245	}
246	print_chr(' '); print_reg(node->v.w);
247	print_chr(' '); print_reg(node->w.w); return;
248	n_r_w:
249	print_chr(' ');
250	if (!(node->flag & jit_flag_node))
251	print_ptr(node->u.p);
252	else {
253	print_chr('L');
254	print_dec(node->u.n->v.w);
255	}
256	print_chr(' '); print_reg(node->v.w);
257	print_chr(' '); print_hex(node->w.w); return;
258	n_r_f:
259	print_chr(' ');
260	if (!(node->flag & jit_flag_node))
261	print_ptr(node->u.p);
262	else{
263	print_chr('L');
264	print_dec(node->u.n->v.w);
265	}
266	print_chr(' '); print_reg(node->v.w);
267	print_chr(' ');
268	if (node->flag & jit_flag_data)
269	print_flt((jit_float32_t )node->w.n->u.w);
270	else
271	print_flt(node->w.f);
272	return;
273	n_r_d:
274	print_chr(' ');
275	if (!(node->flag & jit_flag_node))
276	print_ptr(node->u.p);
277	else {
278	print_chr('L');
279	print_dec(node->u.n->v.w);
280	}
281	print_chr(' '); print_reg(node->v.w);
282	print_chr(' ');
283	if (node->flag & jit_flag_data)
284	print_flt((jit_float64_t )node->w.n->u.w);
285	else
286	print_flt(node->w.d);
287	return;
288	case jit_code_name:
289	print_chr(' ');
290	if (node->v.p && _jitc->emit)
519a9ea1	291	print_str(node->v.n->u.p);
4a71579b PC	292	break;
	293	case jit_code_note:
	294	print_chr(' ');
	295	if (node->v.p && _jitc->emit)
519a9ea1	296	print_str(node->v.n->u.p);
4a71579b PC	297	if (node->v.p && _jitc->emit && node->w.w)
	298	print_chr(':');
	299	if (node->w.w)
	300	print_dec(node->w.w);
	301	break;
	302	case jit_code_data:
	303	case jit_code_label:
	304	case jit_code_ellipsis:
	305	case jit_code_prolog: case jit_code_epilog:
	306	case jit_code_ret: case jit_code_prepare:
	307	break;
	308	case jit_code_save: case jit_code_load:
	309	goto r;
	310	default:
	311	switch (value) {
	312	case jit_cc_a0_reg:
	313	case jit_cc_a0_reg\|jit_cc_a0_chg:
	314	case jit_cc_a0_reg\|jit_cc_a0_jmp:
	315	goto r;
	316	case jit_cc_a0_int:
	317	goto w;
	318	case jit_cc_a0_flt:
	319	goto f;
	320	case jit_cc_a0_dbl:
	321	goto d;
	322	case jit_cc_a0_jmp:
	323	goto n;
	324	case jit_cc_a0_int\|jit_cc_a0_arg:
	325	goto a;
	326	case jit_cc_a0_reg\|jit_cc_a1_reg:
	327	goto r_r;
	328	case jit_cc_a0_reg\|jit_cc_a1_int:
	329	goto r_w;
	330	case jit_cc_a0_reg\|jit_cc_a1_flt:
	331	goto r_f;
	332	case jit_cc_a0_reg\|jit_cc_a1_dbl:
	333	goto r_d;
	334	case jit_cc_a0_reg\|jit_cc_a1_arg:
	335	goto r_a;
	336	case jit_cc_a0_int\|jit_cc_a1_reg:
	337	goto w_r;
	338	case jit_cc_a0_int\|jit_cc_a1_int:
	339	goto w_w;
	340	case jit_cc_a0_int\|jit_cc_a1_arg:
	341	goto w_a;
	342	case jit_cc_a0_flt\|jit_cc_a1_arg:
	343	goto f_a;
	344	case jit_cc_a0_dbl\|jit_cc_a1_arg:
	345	goto d_a;
	346	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_reg:
	347	goto r_r_r;
	348	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_int:
	349	goto r_r_w;
	350	case jit_cc_a0_reg\|jit_cc_a0_rlh\|
	351	jit_cc_a1_reg\|jit_cc_a2_reg:
	352	goto q_r_r;
	353	case jit_cc_a0_reg\|jit_cc_a0_rlh\|
	354	jit_cc_a1_reg\|jit_cc_a2_int:
	355	goto q_r_w;
	356	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_flt:
	357	goto r_r_f;
	358	case jit_cc_a0_reg\|jit_cc_a1_reg\|jit_cc_a2_dbl:
	359	goto r_r_d;
	360	case jit_cc_a0_int\|jit_cc_a1_reg\|jit_cc_a2_reg:
361	goto w_r_r;
362	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_reg:
363	goto n_r_r;
364	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_int:
365	goto n_r_w;
366	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_flt:
367	goto n_r_f;
368	case jit_cc_a0_jmp\|jit_cc_a1_reg\|jit_cc_a2_dbl:
369	goto n_r_d;
370	default:
371	abort();
372	}
373	break;
374	}
375	}