Debian Codegraph @

nx-X11/extras/Mesa/src/mesa/shader/slang/slang_execute.c

raw
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.3
4 *
5 * Copyright (C) 2005 Brian Paul All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /**
26 * \file slang_execute.c
27 * intermediate code interpreter
28 * \author Michal Krol
29 */
30
31 #include "imports.h"
32 #include "slang_utility.h"
33 #include "slang_assemble.h"
34 #include "slang_storage.h"
35 #include "slang_execute.h"
36
37 static void dump_instruction (FILE *f, slang_assembly *a, unsigned int i)
38 {
39 fprintf (f, "%.5u:\t", i);
40
41 switch (a->type)
42 {
43 case slang_asm_none:
44 fprintf (f, "none");
45 break;
46 case slang_asm_float_copy:
47 fprintf (f, "float_copy\t%d, %d", a->param[0], a->param[1]);
48 break;
49 case slang_asm_float_move:
50 fprintf (f, "float_move\t%d, %d", a->param[0], a->param[1]);
51 break;
52 case slang_asm_float_push:
53 fprintf (f, "float_push\t%f", a->literal);
54 break;
55 case slang_asm_float_deref:
56 fprintf (f, "float_deref");
57 break;
58 case slang_asm_float_add:
59 fprintf (f, "float_add");
60 break;
61 case slang_asm_float_multiply:
62 fprintf (f, "float_multiply");
63 break;
64 case slang_asm_float_divide:
65 fprintf (f, "float_divide");
66 break;
67 case slang_asm_float_negate:
68 fprintf (f, "float_negate");
69 break;
70 case slang_asm_float_less:
71 fprintf (f, "float_less");
72 break;
73 case slang_asm_float_equal:
74 fprintf (f, "float_equal\t%d, %d", a->param[0], a->param[1]);
75 break;
76 case slang_asm_float_to_int:
77 fprintf (f, "float_to_int");
78 break;
79 case slang_asm_int_copy:
80 fprintf (f, "int_copy\t%d, %d", a->param[0], a->param[1]);
81 break;
82 case slang_asm_int_move:
83 fprintf (f, "int_move\t%d, %d", a->param[0], a->param[1]);
84 break;
85 case slang_asm_int_push:
86 fprintf (f, "int_push\t%d", (GLint) a->literal);
87 break;
88 case slang_asm_int_deref:
89 fprintf (f, "int_deref");
90 break;
91 case slang_asm_int_to_float:
92 fprintf (f, "int_to_float");
93 break;
94 case slang_asm_int_to_addr:
95 fprintf (f, "int_to_addr");
96 break;
97 case slang_asm_bool_copy:
98 fprintf (f, "bool_copy\t%d, %d", a->param[0], a->param[1]);
99 break;
100 case slang_asm_bool_move:
101 fprintf (f, "bool_move\t%d, %d", a->param[0], a->param[1]);
102 break;
103 case slang_asm_bool_push:
104 fprintf (f, "bool_push\t%d", a->literal != 0.0f);
105 break;
106 case slang_asm_bool_deref:
107 fprintf (f, "bool_deref");
108 break;
109 case slang_asm_addr_copy:
110 fprintf (f, "addr_copy");
111 break;
112 case slang_asm_addr_push:
113 fprintf (f, "addr_push\t%u", a->param[0]);
114 break;
115 case slang_asm_addr_deref:
116 fprintf (f, "addr_deref");
117 break;
118 case slang_asm_addr_add:
119 fprintf (f, "addr_add");
120 break;
121 case slang_asm_addr_multiply:
122 fprintf (f, "addr_multiply");
123 break;
124 case slang_asm_jump:
125 fprintf (f, "jump\t%u", a->param[0]);
126 break;
127 case slang_asm_jump_if_zero:
128 fprintf (f, "jump_if_zero\t%u", a->param[0]);
129 break;
130 case slang_asm_enter:
131 fprintf (f, "enter\t%u", a->param[0]);
132 break;
133 case slang_asm_leave:
134 fprintf (f, "leave");
135 break;
136 case slang_asm_local_alloc:
137 fprintf (f, "local_alloc\t%u", a->param[0]);
138 break;
139 case slang_asm_local_free:
140 fprintf (f, "local_free\t%u", a->param[0]);
141 break;
142 case slang_asm_local_addr:
143 fprintf (f, "local_addr\t%u, %u", a->param[0], a->param[1]);
144 break;
145 case slang_asm_call:
146 fprintf (f, "call\t%u", a->param[0]);
147 break;
148 case slang_asm_return:
149 fprintf (f, "return");
150 break;
151 case slang_asm_discard:
152 fprintf (f, "discard");
153 break;
154 case slang_asm_exit:
155 fprintf (f, "exit");
156 break;
157 default:
158 break;
159 }
160
161 fprintf (f, "\n");
162 }
163
164 static void dump (const slang_assembly_file *file)
165 {
166 unsigned int i;
167 static unsigned int counter = 0;
168 FILE *f;
169 char filename[256];
170
171 counter++;
172 sprintf (filename, "~mesa-slang-assembly-dump-(%u).txt", counter);
173 f = fopen (filename, "w");
174 if (f == NULL)
175 return;
176
177 for (i = 0; i < file->count; i++)
178 dump_instruction (f, file->code + i, i);
179
180 fclose (f);
181 }
182
183 int _slang_execute (const slang_assembly_file *file)
184 {
185 slang_machine mach;
186 FILE *f;
187
188 mach.ip = 0;
189 mach.sp = SLANG_MACHINE_STACK_SIZE;
190 mach.bp = 0;
191 mach.kill = 0;
192 mach.exit = 0;
193
194 /* assume 32-bit machine */
195 /* XXX why???, disabling the pointer size assertions here.
196 * See bug 4021.
197 */
198 static_assert(sizeof (GLfloat) == 4);
199 /*static_assert(sizeof (GLfloat *) == 4);*/
200 static_assert(sizeof (GLuint) == 4);
201 /*static_assert(sizeof (GLuint *) == 4);*/
202
203 dump (file);
204
205 f = fopen ("~mesa-slang-assembly-execution.txt", "w");
206
207 while (!mach.exit)
208 {
209 slang_assembly *a = file->code + mach.ip;
210 if (f != NULL)
211 {
212 unsigned int i;
213 dump_instruction (f, a, mach.ip);
214 fprintf (f, "\t\tsp=%u bp=%u\n", mach.sp, mach.bp);
215 for (i = mach.sp; i < SLANG_MACHINE_STACK_SIZE; i++)
216 fprintf (f, "\t%.5u\t%6f\t%u\n", i, mach.stack._float[i], mach.stack._addr[i]);
217 fflush (f);
218 }
219 mach.ip++;
220
221 switch (a->type)
222 {
223 case slang_asm_none:
224 break;
225 case slang_asm_float_copy:
226 case slang_asm_int_copy:
227 case slang_asm_bool_copy:
228 *(mach.stack._floatp[mach.sp + a->param[0] / 4] + a->param[1] / 4) =
229 mach.stack._float[mach.sp];
230 mach.sp++;
231 break;
232 case slang_asm_float_move:
233 case slang_asm_int_move:
234 case slang_asm_bool_move:
235 mach.stack._float[mach.sp + a->param[0] / 4] =
236 mach.stack._float[mach.sp + (mach.stack._addr[mach.sp] + a->param[1]) / 4];
237 break;
238 case slang_asm_float_push:
239 case slang_asm_int_push:
240 case slang_asm_bool_push:
241 mach.sp--;
242 mach.stack._float[mach.sp] = a->literal;
243 break;
244 case slang_asm_float_deref:
245 case slang_asm_int_deref:
246 case slang_asm_bool_deref:
247 mach.stack._float[mach.sp] = *mach.stack._floatp[mach.sp];
248 break;
249 case slang_asm_float_add:
250 mach.stack._float[mach.sp + 1] += mach.stack._float[mach.sp];
251 mach.sp++;
252 break;
253 case slang_asm_float_multiply:
254 mach.stack._float[mach.sp + 1] *= mach.stack._float[mach.sp];
255 mach.sp++;
256 break;
257 case slang_asm_float_divide:
258 mach.stack._float[mach.sp + 1] /= mach.stack._float[mach.sp];
259 mach.sp++;
260 break;
261 case slang_asm_float_negate:
262 mach.stack._float[mach.sp] = -mach.stack._float[mach.sp];
263 break;
264 case slang_asm_float_less:
265 mach.stack._float[mach.sp + 1] =
266 mach.stack._float[mach.sp + 1] < mach.stack._float[mach.sp] ? 1.0f : 0.0f;
267 mach.sp++;
268 break;
269 case slang_asm_float_equal:
270 mach.sp--;
271 mach.stack._float[mach.sp] = mach.stack._float[mach.sp + 1 + a->param[0] / 4] ==
272 mach.stack._float[mach.sp + 1 + a->param[1] / 4] ? 1.0f : 0.0f;
273 break;
274 case slang_asm_float_to_int:
275 mach.stack._float[mach.sp] = (GLfloat) (GLint) mach.stack._float[mach.sp];
276 break;
277 case slang_asm_int_to_float:
278 break;
279 case slang_asm_int_to_addr:
280 mach.stack._addr[mach.sp] = (GLuint) (GLint) mach.stack._float[mach.sp];
281 break;
282 case slang_asm_addr_copy:
283 *mach.stack._addrp[mach.sp + 1] = mach.stack._addr[mach.sp];
284 mach.sp++;
285 break;
286 case slang_asm_addr_push:
287 mach.sp--;
288 mach.stack._addr[mach.sp] = a->param[0];
289 break;
290 case slang_asm_addr_deref:
291 mach.stack._addr[mach.sp] = *mach.stack._addrp[mach.sp];
292 break;
293 case slang_asm_addr_add:
294 mach.stack._addr[mach.sp + 1] += mach.stack._addr[mach.sp];
295 mach.sp++;
296 break;
297 case slang_asm_addr_multiply:
298 mach.stack._addr[mach.sp + 1] *= mach.stack._addr[mach.sp];
299 mach.sp++;
300 break;
301 case slang_asm_jump:
302 mach.ip = a->param[0];
303 break;
304 case slang_asm_jump_if_zero:
305 if (mach.stack._float[mach.sp] == 0.0f)
306 mach.ip = a->param[0];
307 mach.sp++;
308 break;
309 case slang_asm_enter:
310 mach.sp--;
311 mach.stack._addr[mach.sp] = mach.bp;
312 mach.bp = mach.sp + a->param[0] / 4;
313 break;
314 case slang_asm_leave:
315 mach.bp = mach.stack._addr[mach.sp];
316 mach.sp++;
317 break;
318 case slang_asm_local_alloc:
319 mach.sp -= a->param[0] / 4;
320 break;
321 case slang_asm_local_free:
322 mach.sp += a->param[0] / 4;
323 break;
324 case slang_asm_local_addr:
325 mach.sp--;
326 mach.stack._addr[mach.sp] = (GLuint) mach.stack._addr + mach.bp * 4 -
327 (a->param[0] + a->param[1]) + 4;
328 break;
329 case slang_asm_call:
330 mach.sp--;
331 mach.stack._addr[mach.sp] = mach.ip;
332 mach.ip = a->param[0];
333 break;
334 case slang_asm_return:
335 mach.ip = mach.stack._addr[mach.sp];
336 mach.sp++;
337 break;
338 case slang_asm_discard:
339 mach.kill = 1;
340 break;
341 case slang_asm_exit:
342 mach.exit = 1;
343 break;
344 }
345 }
346
347 if (f != NULL)
348 fclose (f);
349
350 return 0;
351 }
352