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

/*
 * Copyright (C) 2015-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>

#if PROTO
#  define free_synth_list(node)		_free_synth_list(_jit,node)
static jit_node_t *_free_synth_list(jit_state_t*,jit_node_t*);
#define rewind_prolog()			_rewind_prolog(_jit)
static void _rewind_prolog(jit_state_t*);
#define rewind_prepare()		_rewind_prepare(_jit)
static void _rewind_prepare(jit_state_t*);
#endif

#if CODE
/*
 * Implementation
 */
static jit_node_t *
_free_synth_list(jit_state_t *_jit, jit_node_t *node)
{
    jit_node_t		*next;
    next = node->next;
    free_node(node);
    for (node = next; node && (node->flag & jit_flag_synth); node = next) {
	next = node->next;
	free_node(node);
    }
    return (next);
}

static void
_rewind_prolog(jit_state_t *_jit)
{
    jit_node_t		*node;
    jit_node_t		*next;
    _jitc->function->self.size = stack_framesize;
#if __arm__
    assert(jit_cpu.abi);
    _jitc->function->self.size += 64;
#endif
#if __mips__ && NEW_ABI
    /* Only add extra stack space if there are varargs
     * arguments in registers. */
    assert(jit_arg_reg_p(_jitc->function->self.argi));
    _jitc->function->self.size += 64;
#endif
    _jitc->function->self.argi =
	_jitc->function->self.argf = _jitc->function->self.argn = 0;
    _jitc->tail = _jitc->function->prolog;
    node = _jitc->tail->next;
    _jitc->tail->next = (jit_node_t *)0;
    _jitc->tail->link = (jit_node_t *)0;
    for (; node; node = next) {
	next = node->next;
	switch (node->code) {
	    case jit_code_arg:
		node->next = (jit_node_t *)0;
		jit_make_arg(node);
		break;
	    case jit_code_arg_f:
		node->next = (jit_node_t *)0;
		jit_make_arg_f(node);
		break;
	    case jit_code_arg_d:
		node->next = (jit_node_t *)0;
		jit_make_arg_d(node);
		break;
	    case jit_code_getarg_c:
		jit_getarg_c(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_getarg_uc:
		jit_getarg_uc(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_getarg_s:
		jit_getarg_s(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_getarg_us:
		jit_getarg_us(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_getarg_i:
		jit_getarg_i(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_getarg_f:
		jit_getarg_f(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_getarg_d:
		jit_getarg_d(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_putargr:
		jit_putargr(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_putargi:
		jit_putargi(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_putargr_f:
		jit_putargr_f(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_putargi_f:
		jit_putargi_f(node->u.f, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_putargr_d:
		jit_putargr_d(node->u.w, node->v.n);
		next = free_synth_list(node);
		break;
	    case jit_code_putargi_d:
		jit_putargi_d(node->u.d, node->v.n);
		next = free_synth_list(node);
		break;
	    default:
		node->next = (jit_node_t *)0;
		link_node(node);
		break;
	}
    }
}

static void
_rewind_prepare(jit_state_t *_jit)
{
    jit_node_t		*node;
    jit_node_t		*next;
    _jitc->function->call.argi =
	_jitc->function->call.argf =
	_jitc->function->call.size = 0;
    _jitc->tail = _jitc->prepare;
    node = _jitc->tail->next;
    _jitc->tail->next = (jit_node_t *)0;
    _jitc->tail->link = (jit_node_t *)0;
    for (; node; node = next) {
	next = node->next;
	switch (node->code) {
	    case jit_code_pushargr:
		jit_pushargr(node->u.w);
		next = free_synth_list(node);
		break;
	    case jit_code_pushargi:
		jit_pushargi(node->u.w);
		next = free_synth_list(node);
		break;
	    case jit_code_pushargr_f:
		jit_pushargr_f(node->u.w);
		next = free_synth_list(node);
		break;
	    case jit_code_pushargi_f:
		jit_pushargi_f(node->u.f);
		next = free_synth_list(node);
		break;
	    case jit_code_pushargr_d:
		jit_pushargr_d(node->u.w);
		next = free_synth_list(node);
		break;
	    case jit_code_pushargi_d:
		jit_pushargi_d(node->u.d);
		next = free_synth_list(node);
		break;
	    default:
		node->next = (jit_node_t *)0;
		link_node(node);
		break;
	}
    }
}
#endif
Commit	Line	Data
4a71579b PC	1	/*
	2	* Copyright (C) 2015-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
	23	#if PROTO
	24	# define free_synth_list(node) _free_synth_list(_jit,node)
	25	static jit_node_t _free_synth_list(jit_state_t,jit_node_t*);
	26	#define rewind_prolog() _rewind_prolog(_jit)
	27	static void _rewind_prolog(jit_state_t*);
	28	#define rewind_prepare() _rewind_prepare(_jit)
	29	static void _rewind_prepare(jit_state_t*);
	30	#endif
	31
	32	#if CODE
	33	/*
	34	* Implementation
	35	*/
	36	static jit_node_t *
	37	_free_synth_list(jit_state_t _jit, jit_node_t node)
	38	{
	39	jit_node_t *next;
	40	next = node->next;
	41	free_node(node);
	42	for (node = next; node && (node->flag & jit_flag_synth); node = next) {
	43	next = node->next;
	44	free_node(node);
	45	}
	46	return (next);
	47	}
	48
	49	static void
	50	_rewind_prolog(jit_state_t *_jit)
	51	{
	52	jit_node_t *node;
	53	jit_node_t *next;
	54	_jitc->function->self.size = stack_framesize;
	55	#if __arm__
	56	assert(jit_cpu.abi);
	57	_jitc->function->self.size += 64;
	58	#endif
	59	#if __mips__ && NEW_ABI
	60	/* Only add extra stack space if there are varargs
	61	* arguments in registers. */
	62	assert(jit_arg_reg_p(_jitc->function->self.argi));
	63	_jitc->function->self.size += 64;
	64	#endif
65	_jitc->function->self.argi =
66	_jitc->function->self.argf = _jitc->function->self.argn = 0;
67	_jitc->tail = _jitc->function->prolog;
68	node = _jitc->tail->next;
69	_jitc->tail->next = (jit_node_t *)0;
70	_jitc->tail->link = (jit_node_t *)0;
71	for (; node; node = next) {
72	next = node->next;
73	switch (node->code) {
74	case jit_code_arg:
75	node->next = (jit_node_t *)0;
76	jit_make_arg(node);
77	break;
78	case jit_code_arg_f:
79	node->next = (jit_node_t *)0;
80	jit_make_arg_f(node);
81	break;
82	case jit_code_arg_d:
83	node->next = (jit_node_t *)0;
84	jit_make_arg_d(node);
85	break;
86	case jit_code_getarg_c:
87	jit_getarg_c(node->u.w, node->v.n);
88	next = free_synth_list(node);
89	break;
90	case jit_code_getarg_uc:
91	jit_getarg_uc(node->u.w, node->v.n);
92	next = free_synth_list(node);
93	break;
94	case jit_code_getarg_s:
95	jit_getarg_s(node->u.w, node->v.n);
96	next = free_synth_list(node);
97	break;
98	case jit_code_getarg_us:
99	jit_getarg_us(node->u.w, node->v.n);
100	next = free_synth_list(node);
101	break;
102	case jit_code_getarg_i:
103	jit_getarg_i(node->u.w, node->v.n);
104	next = free_synth_list(node);
105	break;
106	case jit_code_getarg_f:
107	jit_getarg_f(node->u.w, node->v.n);
108	next = free_synth_list(node);
109	break;
110	case jit_code_getarg_d:
111	jit_getarg_d(node->u.w, node->v.n);
112	next = free_synth_list(node);
113	break;
114	case jit_code_putargr:
115	jit_putargr(node->u.w, node->v.n);
116	next = free_synth_list(node);
117	break;
118	case jit_code_putargi:
119	jit_putargi(node->u.w, node->v.n);
120	next = free_synth_list(node);
121	break;
122	case jit_code_putargr_f:
123	jit_putargr_f(node->u.w, node->v.n);
124	next = free_synth_list(node);
125	break;
126	case jit_code_putargi_f:
127	jit_putargi_f(node->u.f, node->v.n);
128	next = free_synth_list(node);
129	break;
130	case jit_code_putargr_d:
131	jit_putargr_d(node->u.w, node->v.n);
132	next = free_synth_list(node);
133	break;
134	case jit_code_putargi_d:
135	jit_putargi_d(node->u.d, node->v.n);
136	next = free_synth_list(node);
137	break;
138	default:
139	node->next = (jit_node_t *)0;
140	link_node(node);
141	break;
142	}
143	}
144	}
145
146	static void
147	_rewind_prepare(jit_state_t *_jit)
148	{
149	jit_node_t *node;
150	jit_node_t *next;
151	_jitc->function->call.argi =
152	_jitc->function->call.argf =
153	_jitc->function->call.size = 0;
154	_jitc->tail = _jitc->prepare;
155	node = _jitc->tail->next;
156	_jitc->tail->next = (jit_node_t *)0;
157	_jitc->tail->link = (jit_node_t *)0;
158	for (; node; node = next) {
159	next = node->next;
160	switch (node->code) {
161	case jit_code_pushargr:
162	jit_pushargr(node->u.w);
163	next = free_synth_list(node);
164	break;
165	case jit_code_pushargi:
166	jit_pushargi(node->u.w);
167	next = free_synth_list(node);
168	break;
169	case jit_code_pushargr_f:
170	jit_pushargr_f(node->u.w);
171	next = free_synth_list(node);
172	break;
173	case jit_code_pushargi_f:
174	jit_pushargi_f(node->u.f);
175	next = free_synth_list(node);
176	break;
177	case jit_code_pushargr_d:
178	jit_pushargr_d(node->u.w);
179	next = free_synth_list(node);
180	break;
181	case jit_code_pushargi_d:
182	jit_pushargi_d(node->u.d);
183	next = free_synth_list(node);
184	break;
185	default:
186	node->next = (jit_node_t *)0;
187	link_node(node);
188	break;
189	}
190	}
191	}
192	#endif