add a thp-based huge page alloc fallback
[pcsx_rearmed.git] / deps / lightning / lib / jit_rewind.c
1 /*
2  * Copyright (C) 2015-2023  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->alist = NULL;
58 #elif __mips__
59     _jitc->function->alist = NULL;
60 #endif
61     _jitc->function->self.argi =
62         _jitc->function->self.argf = _jitc->function->self.argn = 0;
63     _jitc->tail = _jitc->function->prolog;
64     node = _jitc->tail->next;
65     _jitc->tail->next = (jit_node_t *)0;
66     _jitc->tail->link = (jit_node_t *)0;
67     for (; node; node = next) {
68         next = node->next;
69         switch (node->code) {
70             case jit_code_arg_c:        case jit_code_arg_s:
71             case jit_code_arg_i:        case jit_code_arg_l:
72                 node->next = (jit_node_t *)0;
73                 jit_make_arg(node, node->code);
74                 break;
75             case jit_code_arg_f:
76                 node->next = (jit_node_t *)0;
77                 jit_make_arg_f(node);
78                 break;
79             case jit_code_arg_d:
80                 node->next = (jit_node_t *)0;
81                 jit_make_arg_d(node);
82                 break;
83             case jit_code_getarg_c:
84                 jit_getarg_c(node->u.w, node->v.n);
85                 next = free_synth_list(node);
86                 break;
87             case jit_code_getarg_uc:
88                 jit_getarg_uc(node->u.w, node->v.n);
89                 next = free_synth_list(node);
90                 break;
91             case jit_code_getarg_s:
92                 jit_getarg_s(node->u.w, node->v.n);
93                 next = free_synth_list(node);
94                 break;
95             case jit_code_getarg_us:
96                 jit_getarg_us(node->u.w, node->v.n);
97                 next = free_synth_list(node);
98                 break;
99             case jit_code_getarg_i:
100                 jit_getarg_i(node->u.w, node->v.n);
101                 next = free_synth_list(node);
102                 break;
103             case jit_code_getarg_f:
104                 jit_getarg_f(node->u.w, node->v.n);
105                 next = free_synth_list(node);
106                 break;
107             case jit_code_getarg_d:
108                 jit_getarg_d(node->u.w, node->v.n);
109                 next = free_synth_list(node);
110                 break;
111             case jit_code_putargr:
112                 jit_putargr(node->u.w, node->v.n);
113                 next = free_synth_list(node);
114                 break;
115             case jit_code_putargi:
116                 jit_putargi(node->u.w, node->v.n);
117                 next = free_synth_list(node);
118                 break;
119             case jit_code_putargr_f:
120                 jit_putargr_f(node->u.w, node->v.n);
121                 next = free_synth_list(node);
122                 break;
123             case jit_code_putargi_f:
124                 jit_putargi_f(node->u.f, node->v.n);
125                 next = free_synth_list(node);
126                 break;
127             case jit_code_putargr_d:
128                 jit_putargr_d(node->u.w, node->v.n);
129                 next = free_synth_list(node);
130                 break;
131             case jit_code_putargi_d:
132                 jit_putargi_d(node->u.d, node->v.n);
133                 next = free_synth_list(node);
134                 break;
135             default:
136                 node->next = (jit_node_t *)0;
137                 link_node(node);
138                 break;
139         }
140     }
141 }
142
143 static void
144 _rewind_prepare(jit_state_t *_jit)
145 {
146     jit_node_t          *node;
147     jit_node_t          *next;
148     _jitc->function->call.argi =
149         _jitc->function->call.argf =
150         _jitc->function->call.size = 0;
151     _jitc->tail = _jitc->prepare;
152     node = _jitc->tail->next;
153     _jitc->tail->next = (jit_node_t *)0;
154     _jitc->tail->link = (jit_node_t *)0;
155     for (; node; node = next) {
156         next = node->next;
157         switch (node->code) {
158             case jit_code_pushargr:
159                 jit_pushargr(node->u.w);
160                 next = free_synth_list(node);
161                 break;
162             case jit_code_pushargi:
163                 jit_pushargi(node->u.w);
164                 next = free_synth_list(node);
165                 break;
166             case jit_code_pushargr_f:
167                 jit_pushargr_f(node->u.w);
168                 next = free_synth_list(node);
169                 break;
170             case jit_code_pushargi_f:
171                 jit_pushargi_f(node->u.f);
172                 next = free_synth_list(node);
173                 break;
174             case jit_code_pushargr_d:
175                 jit_pushargr_d(node->u.w);
176                 next = free_synth_list(node);
177                 break;
178             case jit_code_pushargi_d:
179                 jit_pushargi_d(node->u.d);
180                 next = free_synth_list(node);
181                 break;
182             default:
183                 node->next = (jit_node_t *)0;
184                 link_node(node);
185                 break;
186         }
187     }
188 }
189 #endif