← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/mesa/shader/slang/slang_execute.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/shader/slang/slang_execute.c
36
36
 
37
37
#define DEBUG_SLANG 0
38
38
 
39
 
GLvoid slang_machine_ctr (slang_machine *self)
 
39
GLvoid
 
40
slang_machine_ctr(slang_machine * self)
40
41
{
41
 
        slang_machine_init (self);
 
42
   slang_machine_init(self);
42
43
   self->infolog = NULL;
43
44
#if defined(USE_X86_ASM) || defined(SLANG_X86)
44
 
        self->x86.compiled_func = NULL;
 
45
   self->x86.compiled_func = NULL;
45
46
#endif
46
47
}
47
48
 
48
 
GLvoid slang_machine_dtr (slang_machine *self)
 
49
GLvoid
 
50
slang_machine_dtr(slang_machine * self)
49
51
{
50
52
   if (self->infolog != NULL) {
51
 
      slang_info_log_destruct (self->infolog);
52
 
      slang_alloc_free (self->infolog);
 
53
      slang_info_log_destruct(self->infolog);
 
54
      slang_alloc_free(self->infolog);
53
55
   }
54
56
#if defined(USE_X86_ASM) || defined(SLANG_X86)
55
 
        if (self->x86.compiled_func != NULL)
56
 
                _mesa_exec_free (self->x86.compiled_func);
 
57
   if (self->x86.compiled_func != NULL)
 
58
      _mesa_exec_free(self->x86.compiled_func);
57
59
#endif
58
60
}
59
61
 
60
 
void slang_machine_init (slang_machine *mach)
 
62
 
 
63
/**
 
64
 * Initialize the shader virtual machine.
 
65
 * NOTE: stack grows downward in memory.
 
66
 */
 
67
void
 
68
slang_machine_init(slang_machine * mach)
61
69
{
62
 
        mach->ip = 0;
63
 
        mach->sp = SLANG_MACHINE_STACK_SIZE;
64
 
        mach->bp = 0;
65
 
        mach->kill = 0;
66
 
        mach->exit = 0;
 
70
   mach->ip = 0;
 
71
   mach->sp = SLANG_MACHINE_STACK_SIZE;
 
72
   mach->bp = 0;
 
73
   mach->kill = GL_FALSE;
 
74
   mach->exit = GL_FALSE;
67
75
}
68
76
 
69
77
#if DEBUG_SLANG
70
78
 
71
 
static void dump_instruction (FILE *f, slang_assembly *a, unsigned int i)
 
79
static void
 
80
dump_instruction(FILE * f, slang_assembly * a, unsigned int i)
72
81
{
73
 
        fprintf (f, "%.5u:\t", i);
74
 
        
75
 
        switch (a->type)
76
 
        {
77
 
        /* core */
78
 
        case slang_asm_none:
79
 
                fprintf (f, "none");
80
 
                break;
81
 
        case slang_asm_float_copy:
82
 
                fprintf (f, "float_copy\t%d, %d", a->param[0], a->param[1]);
83
 
                break;
84
 
        case slang_asm_float_move:
85
 
                fprintf (f, "float_move\t%d, %d", a->param[0], a->param[1]);
86
 
                break;
87
 
        case slang_asm_float_push:
88
 
                fprintf (f, "float_push\t%f", a->literal);
89
 
                break;
90
 
        case slang_asm_float_deref:
91
 
                fprintf (f, "float_deref");
92
 
                break;
93
 
        case slang_asm_float_add:
94
 
                fprintf (f, "float_add");
95
 
                break;
96
 
        case slang_asm_float_multiply:
97
 
                fprintf (f, "float_multiply");
98
 
                break;
99
 
        case slang_asm_float_divide:
100
 
                fprintf (f, "float_divide");
101
 
                break;
102
 
        case slang_asm_float_negate:
103
 
                fprintf (f, "float_negate");
104
 
                break;
105
 
        case slang_asm_float_less:
106
 
                fprintf (f, "float_less");
107
 
                break;
108
 
        case slang_asm_float_equal_exp:
109
 
                fprintf (f, "float_equal");
110
 
                break;
111
 
        case slang_asm_float_equal_int:
112
 
                fprintf (f, "float_equal\t%d, %d", a->param[0], a->param[1]);
113
 
                break;
114
 
        case slang_asm_float_to_int:
115
 
                fprintf (f, "float_to_int");
116
 
                break;
117
 
        case slang_asm_float_sine:
118
 
                fprintf (f, "float_sine");
119
 
                break;
120
 
        case slang_asm_float_arcsine:
121
 
                fprintf (f, "float_arcsine");
122
 
                break;
123
 
        case slang_asm_float_arctan:
124
 
                fprintf (f, "float_arctan");
125
 
                break;
126
 
        case slang_asm_float_power:
127
 
                fprintf (f, "float_power");
128
 
                break;
129
 
        case slang_asm_float_log2:
130
 
                fprintf (f, "float_log2");
131
 
                break;
132
 
        case slang_asm_float_floor:
133
 
                fprintf (f, "float_floor");
134
 
                break;
135
 
        case slang_asm_float_ceil:
136
 
                fprintf (f, "float_ceil");
137
 
                break;
138
 
        case slang_asm_float_noise1:
139
 
                fprintf (f, "float_noise1");
140
 
                break;
141
 
        case slang_asm_float_noise2:
142
 
                fprintf (f, "float_noise2");
143
 
                break;
144
 
        case slang_asm_float_noise3:
145
 
                fprintf (f, "float_noise3");
146
 
                break;
147
 
        case slang_asm_float_noise4:
148
 
                fprintf (f, "float_noise4");
149
 
                break;
150
 
        case slang_asm_int_copy:
151
 
                fprintf (f, "int_copy\t%d, %d", a->param[0], a->param[1]);
152
 
                break;
153
 
        case slang_asm_int_move:
154
 
                fprintf (f, "int_move\t%d, %d", a->param[0], a->param[1]);
155
 
                break;
156
 
        case slang_asm_int_push:
157
 
                fprintf (f, "int_push\t%d", (GLint) a->literal);
158
 
                break;
159
 
        case slang_asm_int_deref:
160
 
                fprintf (f, "int_deref");
161
 
                break;
162
 
        case slang_asm_int_to_float:
163
 
                fprintf (f, "int_to_float");
164
 
                break;
165
 
        case slang_asm_int_to_addr:
166
 
                fprintf (f, "int_to_addr");
167
 
                break;
168
 
        case slang_asm_bool_copy:
169
 
                fprintf (f, "bool_copy\t%d, %d", a->param[0], a->param[1]);
170
 
                break;
171
 
        case slang_asm_bool_move:
172
 
                fprintf (f, "bool_move\t%d, %d", a->param[0], a->param[1]);
173
 
                break;
174
 
        case slang_asm_bool_push:
175
 
                fprintf (f, "bool_push\t%d", a->literal != 0.0f);
176
 
                break;
177
 
        case slang_asm_bool_deref:
178
 
                fprintf (f, "bool_deref");
179
 
                break;
180
 
        case slang_asm_addr_copy:
181
 
                fprintf (f, "addr_copy");
182
 
                break;
183
 
        case slang_asm_addr_push:
184
 
                fprintf (f, "addr_push\t%u", a->param[0]);
185
 
                break;
186
 
        case slang_asm_addr_deref:
187
 
                fprintf (f, "addr_deref");
188
 
                break;
189
 
        case slang_asm_addr_add:
190
 
                fprintf (f, "addr_add");
191
 
                break;
192
 
        case slang_asm_addr_multiply:
193
 
                fprintf (f, "addr_multiply");
194
 
                break;
195
 
        case slang_asm_vec4_tex1d:
196
 
                fprintf (f, "vec4_tex1d");
197
 
                break;
198
 
        case slang_asm_vec4_tex2d:
199
 
                fprintf (f, "vec4_tex2d");
200
 
                break;
201
 
        case slang_asm_vec4_tex3d:
202
 
                fprintf (f, "vec4_tex3d");
203
 
                break;
204
 
        case slang_asm_vec4_texcube:
205
 
                fprintf (f, "vec4_texcube");
206
 
                break;
207
 
        case slang_asm_vec4_shad1d:
208
 
                fprintf (f, "vec4_shad1d");
209
 
                break;
210
 
        case slang_asm_vec4_shad2d:
211
 
                fprintf (f, "vec4_shad2d");
212
 
                break;
213
 
        case slang_asm_jump:
214
 
                fprintf (f, "jump\t%u", a->param[0]);
215
 
                break;
216
 
        case slang_asm_jump_if_zero:
217
 
                fprintf (f, "jump_if_zero\t%u", a->param[0]);
218
 
                break;
219
 
        case slang_asm_enter:
220
 
                fprintf (f, "enter\t%u", a->param[0]);
221
 
                break;
222
 
        case slang_asm_leave:
223
 
                fprintf (f, "leave");
224
 
                break;
225
 
        case slang_asm_local_alloc:
226
 
                fprintf (f, "local_alloc\t%u", a->param[0]);
227
 
                break;
228
 
        case slang_asm_local_free:
229
 
                fprintf (f, "local_free\t%u", a->param[0]);
230
 
                break;
231
 
        case slang_asm_local_addr:
232
 
                fprintf (f, "local_addr\t%u, %u", a->param[0], a->param[1]);
233
 
                break;
234
 
        case slang_asm_global_addr:
235
 
                fprintf (f, "global_addr\t%u", a->param[0]);
236
 
                break;
237
 
        case slang_asm_call:
238
 
                fprintf (f, "call\t%u", a->param[0]);
239
 
                break;
240
 
        case slang_asm_return:
241
 
                fprintf (f, "return");
242
 
                break;
243
 
        case slang_asm_discard:
244
 
                fprintf (f, "discard");
245
 
                break;
246
 
        case slang_asm_exit:
247
 
                fprintf (f, "exit");
248
 
                break;
249
 
        /* mesa-specific extensions */
250
 
        case slang_asm_float_print:
251
 
                fprintf (f, "float_print");
252
 
                break;
253
 
        case slang_asm_int_print:
254
 
                fprintf (f, "int_print");
255
 
                break;
256
 
        case slang_asm_bool_print:
257
 
                fprintf (f, "bool_print");
258
 
                break;
259
 
        default:
260
 
                break;
261
 
        }
262
 
 
263
 
        fprintf (f, "\n");
 
82
   fprintf(f, "%.5u:\t", i);
 
83
 
 
84
   switch (a->type) {
 
85
      /* core */
 
86
   case slang_asm_none:
 
87
      fprintf(f, "none");
 
88
      break;
 
89
   case slang_asm_float_copy:
 
90
      fprintf(f, "float_copy\t%d, %d", a->param[0], a->param[1]);
 
91
      break;
 
92
   case slang_asm_float_move:
 
93
      fprintf(f, "float_move\t%d, %d", a->param[0], a->param[1]);
 
94
      break;
 
95
   case slang_asm_float_push:
 
96
      fprintf(f, "float_push\t%f", a->literal);
 
97
      break;
 
98
   case slang_asm_float_deref:
 
99
      fprintf(f, "float_deref");
 
100
      break;
 
101
   case slang_asm_float_add:
 
102
      fprintf(f, "float_add");
 
103
      break;
 
104
   case slang_asm_float_multiply:
 
105
      fprintf(f, "float_multiply");
 
106
      break;
 
107
   case slang_asm_float_divide:
 
108
      fprintf(f, "float_divide");
 
109
      break;
 
110
   case slang_asm_float_negate:
 
111
      fprintf(f, "float_negate");
 
112
      break;
 
113
   case slang_asm_float_less:
 
114
      fprintf(f, "float_less");
 
115
      break;
 
116
   case slang_asm_float_equal_exp:
 
117
      fprintf(f, "float_equal");
 
118
      break;
 
119
   case slang_asm_float_equal_int:
 
120
      fprintf(f, "float_equal\t%d, %d", a->param[0], a->param[1]);
 
121
      break;
 
122
   case slang_asm_float_to_int:
 
123
      fprintf(f, "float_to_int");
 
124
      break;
 
125
   case slang_asm_float_sine:
 
126
      fprintf(f, "float_sine");
 
127
      break;
 
128
   case slang_asm_float_arcsine:
 
129
      fprintf(f, "float_arcsine");
 
130
      break;
 
131
   case slang_asm_float_arctan:
 
132
      fprintf(f, "float_arctan");
 
133
      break;
 
134
   case slang_asm_float_power:
 
135
      fprintf(f, "float_power");
 
136
      break;
 
137
   case slang_asm_float_log2:
 
138
      fprintf(f, "float_log2");
 
139
      break;
 
140
   case slang_asm_float_floor:
 
141
      fprintf(f, "float_floor");
 
142
      break;
 
143
   case slang_asm_float_ceil:
 
144
      fprintf(f, "float_ceil");
 
145
      break;
 
146
   case slang_asm_float_noise1:
 
147
      fprintf(f, "float_noise1");
 
148
      break;
 
149
   case slang_asm_float_noise2:
 
150
      fprintf(f, "float_noise2");
 
151
      break;
 
152
   case slang_asm_float_noise3:
 
153
      fprintf(f, "float_noise3");
 
154
      break;
 
155
   case slang_asm_float_noise4:
 
156
      fprintf(f, "float_noise4");
 
157
      break;
 
158
   case slang_asm_int_copy:
 
159
      fprintf(f, "int_copy\t%d, %d", a->param[0], a->param[1]);
 
160
      break;
 
161
   case slang_asm_int_move:
 
162
      fprintf(f, "int_move\t%d, %d", a->param[0], a->param[1]);
 
163
      break;
 
164
   case slang_asm_int_push:
 
165
      fprintf(f, "int_push\t%d", (GLint) a->literal);
 
166
      break;
 
167
   case slang_asm_int_deref:
 
168
      fprintf(f, "int_deref");
 
169
      break;
 
170
   case slang_asm_int_to_float:
 
171
      fprintf(f, "int_to_float");
 
172
      break;
 
173
   case slang_asm_int_to_addr:
 
174
      fprintf(f, "int_to_addr");
 
175
      break;
 
176
   case slang_asm_bool_copy:
 
177
      fprintf(f, "bool_copy\t%d, %d", a->param[0], a->param[1]);
 
178
      break;
 
179
   case slang_asm_bool_move:
 
180
      fprintf(f, "bool_move\t%d, %d", a->param[0], a->param[1]);
 
181
      break;
 
182
   case slang_asm_bool_push:
 
183
      fprintf(f, "bool_push\t%d", a->literal != 0.0f);
 
184
      break;
 
185
   case slang_asm_bool_deref:
 
186
      fprintf(f, "bool_deref");
 
187
      break;
 
188
   case slang_asm_addr_copy:
 
189
      fprintf(f, "addr_copy");
 
190
      break;
 
191
   case slang_asm_addr_push:
 
192
      fprintf(f, "addr_push\t%u", a->param[0]);
 
193
      break;
 
194
   case slang_asm_addr_deref:
 
195
      fprintf(f, "addr_deref");
 
196
      break;
 
197
   case slang_asm_addr_add:
 
198
      fprintf(f, "addr_add");
 
199
      break;
 
200
   case slang_asm_addr_multiply:
 
201
      fprintf(f, "addr_multiply");
 
202
      break;
 
203
   case slang_asm_vec4_tex1d:
 
204
      fprintf(f, "vec4_tex1d");
 
205
      break;
 
206
   case slang_asm_vec4_tex2d:
 
207
      fprintf(f, "vec4_tex2d");
 
208
      break;
 
209
   case slang_asm_vec4_tex3d:
 
210
      fprintf(f, "vec4_tex3d");
 
211
      break;
 
212
   case slang_asm_vec4_texcube:
 
213
      fprintf(f, "vec4_texcube");
 
214
      break;
 
215
   case slang_asm_vec4_shad1d:
 
216
      fprintf(f, "vec4_shad1d");
 
217
      break;
 
218
   case slang_asm_vec4_shad2d:
 
219
      fprintf(f, "vec4_shad2d");
 
220
      break;
 
221
   case slang_asm_jump:
 
222
      fprintf(f, "jump\t%u", a->param[0]);
 
223
      break;
 
224
   case slang_asm_jump_if_zero:
 
225
      fprintf(f, "jump_if_zero\t%u", a->param[0]);
 
226
      break;
 
227
   case slang_asm_enter:
 
228
      fprintf(f, "enter\t%u", a->param[0]);
 
229
      break;
 
230
   case slang_asm_leave:
 
231
      fprintf(f, "leave");
 
232
      break;
 
233
   case slang_asm_local_alloc:
 
234
      fprintf(f, "local_alloc\t%u", a->param[0]);
 
235
      break;
 
236
   case slang_asm_local_free:
 
237
      fprintf(f, "local_free\t%u", a->param[0]);
 
238
      break;
 
239
   case slang_asm_local_addr:
 
240
      fprintf(f, "local_addr\t%u, %u", a->param[0], a->param[1]);
 
241
      break;
 
242
   case slang_asm_global_addr:
 
243
      fprintf(f, "global_addr\t%u", a->param[0]);
 
244
      break;
 
245
   case slang_asm_call:
 
246
      fprintf(f, "call\t%u", a->param[0]);
 
247
      break;
 
248
   case slang_asm_return:
 
249
      fprintf(f, "return");
 
250
      break;
 
251
   case slang_asm_discard:
 
252
      fprintf(f, "discard");
 
253
      break;
 
254
   case slang_asm_exit:
 
255
      fprintf(f, "exit");
 
256
      break;
 
257
      /* GL_MESA_shader_debug */
 
258
   case slang_asm_float_print:
 
259
      fprintf(f, "float_print");
 
260
      break;
 
261
   case slang_asm_int_print:
 
262
      fprintf(f, "int_print");
 
263
      break;
 
264
   case slang_asm_bool_print:
 
265
      fprintf(f, "bool_print");
 
266
      break;
 
267
      /* vec4 */
 
268
   case slang_asm_float_to_vec4:
 
269
      fprintf(f, "float_to_vec4");
 
270
      break;
 
271
   case slang_asm_vec4_add:
 
272
      fprintf(f, "vec4_add");
 
273
      break;
 
274
   case slang_asm_vec4_subtract:
 
275
      fprintf(f, "vec4_subtract");
 
276
      break;
 
277
   case slang_asm_vec4_multiply:
 
278
      fprintf(f, "vec4_multiply");
 
279
      break;
 
280
   case slang_asm_vec4_divide:
 
281
      fprintf(f, "vec4_divide");
 
282
      break;
 
283
   case slang_asm_vec4_negate:
 
284
      fprintf(f, "vec4_negate");
 
285
      break;
 
286
   case slang_asm_vec4_dot:
 
287
      fprintf(f, "vec4_dot");
 
288
      break;
 
289
   case slang_asm_vec4_copy:
 
290
      fprintf(f, "vec4_copy");
 
291
      break;
 
292
   case slang_asm_vec4_deref:
 
293
      fprintf(f, "vec4_deref");
 
294
      break;
 
295
   case slang_asm_vec4_equal_int:
 
296
      fprintf(f, "vec4_equal");
 
297
      break;
 
298
   default:
 
299
      break;
 
300
   }
 
301
 
 
302
   fprintf(f, "\n");
264
303
}
265
304
 
266
 
static void dump (const slang_assembly_file *file)
 
305
static void
 
306
dump(const slang_assembly_file * file)
267
307
{
268
 
        unsigned int i;
269
 
        static unsigned int counter = 0;
270
 
        FILE *f;
271
 
        char filename[256];
272
 
 
273
 
        counter++;
274
 
        _mesa_sprintf (filename, "~mesa-slang-assembly-dump-(%u).txt", counter);
275
 
        f = fopen (filename, "w");
276
 
        if (f == NULL)
277
 
                return;
278
 
 
279
 
        for (i = 0; i < file->count; i++)
280
 
                dump_instruction (f, file->code + i, i);
281
 
 
282
 
        fclose (f);
 
308
   unsigned int i;
 
309
   static unsigned int counter = 0;
 
310
   FILE *f;
 
311
   char filename[256];
 
312
 
 
313
   counter++;
 
314
   _mesa_sprintf(filename, "~mesa-slang-assembly-dump-(%u).txt", counter);
 
315
   f = fopen(filename, "w");
 
316
   if (f == NULL)
 
317
      return;
 
318
 
 
319
   for (i = 0; i < file->count; i++)
 
320
      dump_instruction(f, file->code + i, i);
 
321
 
 
322
   fclose(f);
283
323
}
284
324
 
285
325
#endif
286
326
 
287
327
static GLvoid
288
 
ensure_infolog_created (slang_info_log **infolog)
 
328
ensure_infolog_created(slang_info_log ** infolog)
289
329
{
290
330
   if (*infolog == NULL) {
291
 
      *infolog = slang_alloc_malloc (sizeof (slang_info_log));
 
331
      *infolog = slang_alloc_malloc(sizeof(slang_info_log));
292
332
      if (*infolog == NULL)
293
333
         return;
294
 
      slang_info_log_construct (*infolog);
 
334
      slang_info_log_construct(*infolog);
295
335
   }
296
336
}
297
337
 
298
 
int _slang_execute2 (const slang_assembly_file *file, slang_machine *mach)
 
338
GLboolean
 
339
_slang_execute2(const slang_assembly_file * file, slang_machine * mach)
299
340
{
300
 
        slang_machine_slot *stack;
 
341
   slang_machine_slot *stack;
301
342
 
302
343
#if DEBUG_SLANG
303
 
        static unsigned int counter = 0;
304
 
        char filename[256];
305
 
        FILE *f;
 
344
   static unsigned int counter = 0;
 
345
   char filename[256];
 
346
   FILE *f;
306
347
#endif
307
348
 
308
 
        /* assume 32-bit floats and uints; should work fine also on 64-bit platforms */
309
 
        static_assert(sizeof (GLfloat) == 4);
310
 
        static_assert(sizeof (GLuint) == 4);
 
349
   /* assume 32-bit floats and uints; should work fine also on 64-bit platforms */
 
350
   static_assert(sizeof(GLfloat) == 4);
 
351
   static_assert(sizeof(GLuint) == 4);
311
352
 
312
353
#if DEBUG_SLANG
313
 
        dump (file);
314
 
        counter++;
315
 
        _mesa_sprintf (filename, "~mesa-slang-assembly-exec-(%u).txt", counter);
316
 
        f = fopen (filename, "w");
 
354
   dump(file);
 
355
   counter++;
 
356
   _mesa_sprintf(filename, "~mesa-slang-assembly-exec-(%u).txt", counter);
 
357
   f = fopen(filename, "w");
317
358
#endif
318
359
 
319
360
#if defined(USE_X86_ASM) || defined(SLANG_X86)
320
 
        if (mach->x86.compiled_func != NULL)
321
 
        {
322
 
                mach->x86.compiled_func (mach);
323
 
                return 1;
324
 
        }
325
 
#endif
326
 
 
327
 
        stack = mach->mem + SLANG_MACHINE_GLOBAL_SIZE;
328
 
 
329
 
        while (!mach->exit)
330
 
        {
331
 
                slang_assembly *a = &file->code[mach->ip];
332
 
 
333
 
#if DEBUG_SLANG
334
 
                if (f != NULL && a->type != slang_asm_none)
335
 
                {
336
 
                        unsigned int i;
337
 
 
338
 
                        dump_instruction (f, file->code + mach->ip, mach->ip);
339
 
                        fprintf (f, "\t\tsp=%u bp=%u\n", mach->sp, mach->bp);
340
 
                        for (i = mach->sp; i < SLANG_MACHINE_STACK_SIZE; i++)
341
 
                                fprintf (f, "\t%.5u\t%6f\t%u\n", i, stack[i]._float, stack[i]._addr);
342
 
                        fflush (f);
343
 
                }
344
 
#endif
345
 
 
346
 
                mach->ip++;
347
 
 
348
 
                switch (a->type)
349
 
                {
350
 
                /* core */
351
 
                case slang_asm_none:
352
 
                        break;
353
 
                case slang_asm_float_copy:
354
 
                case slang_asm_int_copy:
355
 
                case slang_asm_bool_copy:
356
 
                        mach->mem[(stack[mach->sp + a->param[0] / 4]._addr + a->param[1]) / 4]._float =
357
 
                                stack[mach->sp]._float;
358
 
                        mach->sp++;
359
 
                        break;
360
 
                case slang_asm_float_move:
361
 
                case slang_asm_int_move:
362
 
                case slang_asm_bool_move:
363
 
                        stack[mach->sp + a->param[0] / 4]._float =
364
 
                                stack[mach->sp + (stack[mach->sp]._addr + a->param[1]) / 4]._float;
365
 
                        break;
366
 
                case slang_asm_float_push:
367
 
                case slang_asm_int_push:
368
 
                case slang_asm_bool_push:
369
 
                        mach->sp--;
370
 
                        stack[mach->sp]._float = a->literal;
371
 
                        break;
372
 
                case slang_asm_float_deref:
373
 
                case slang_asm_int_deref:
374
 
                case slang_asm_bool_deref:
375
 
                        stack[mach->sp]._float = mach->mem[stack[mach->sp]._addr / 4]._float;
376
 
                        break;
377
 
                case slang_asm_float_add:
378
 
                        stack[mach->sp + 1]._float += stack[mach->sp]._float;
379
 
                        mach->sp++;
380
 
                        break;
381
 
                case slang_asm_float_multiply:
382
 
                        stack[mach->sp + 1]._float *= stack[mach->sp]._float;
383
 
                        mach->sp++;
384
 
                        break;
385
 
                case slang_asm_float_divide:
386
 
                        stack[mach->sp + 1]._float /= stack[mach->sp]._float;
387
 
                        mach->sp++;
388
 
                        break;
389
 
                case slang_asm_float_negate:
390
 
                        stack[mach->sp]._float = -stack[mach->sp]._float;
391
 
                        break;
392
 
                case slang_asm_float_less:
393
 
                        stack[mach->sp + 1]._float =
394
 
                                stack[mach->sp + 1]._float < stack[mach->sp]._float ? (GLfloat) 1 : (GLfloat) 0;
395
 
                        mach->sp++;
396
 
                        break;
397
 
                case slang_asm_float_equal_exp:
398
 
                        stack[mach->sp + 1]._float =
399
 
                                stack[mach->sp + 1]._float == stack[mach->sp]._float ? (GLfloat) 1 : (GLfloat) 0;
400
 
                        mach->sp++;
401
 
                        break;
402
 
                case slang_asm_float_equal_int:
403
 
                        mach->sp--;
404
 
                        stack[mach->sp]._float = stack[mach->sp + 1 + a->param[0] / 4]._float ==
405
 
                                stack[mach->sp + 1 + a->param[1] / 4]._float ? (GLfloat) 1 : (GLfloat) 0;
406
 
                        break;
407
 
                case slang_asm_float_to_int:
408
 
                        stack[mach->sp]._float = (GLfloat) (GLint) stack[mach->sp]._float;
409
 
                        break;
410
 
                case slang_asm_float_sine:
411
 
                        stack[mach->sp]._float = (GLfloat) _mesa_sin (stack[mach->sp]._float);
412
 
                        break;
413
 
                case slang_asm_float_arcsine:
414
 
                        stack[mach->sp]._float = _mesa_asinf (stack[mach->sp]._float);
415
 
                        break;
416
 
                case slang_asm_float_arctan:
417
 
                        stack[mach->sp]._float = _mesa_atanf (stack[mach->sp]._float);
418
 
                        break;
419
 
                case slang_asm_float_power:
420
 
                        stack[mach->sp + 1]._float =
421
 
                                (GLfloat) _mesa_pow (stack[mach->sp + 1]._float, stack[mach->sp]._float);
422
 
                        mach->sp++;
423
 
                        break;
424
 
                case slang_asm_float_log2:
425
 
                        stack[mach->sp]._float = LOG2 (stack[mach->sp]._float);
426
 
                        break;
427
 
                case slang_asm_float_floor:
428
 
                        stack[mach->sp]._float = FLOORF (stack[mach->sp]._float);
429
 
                        break;
430
 
                case slang_asm_float_ceil:
431
 
                        stack[mach->sp]._float = CEILF (stack[mach->sp]._float);
432
 
                        break;
433
 
                case slang_asm_float_noise1:
434
 
                        stack[mach->sp]._float = _slang_library_noise1 (stack[mach->sp]._float);
435
 
                        break;
436
 
                case slang_asm_float_noise2:
437
 
                        stack[mach->sp + 1]._float = _slang_library_noise2 (stack[mach->sp]._float,
438
 
                                stack[mach->sp + 1]._float);
439
 
                        mach->sp++;
440
 
                        break;
441
 
                case slang_asm_float_noise3:
442
 
                        stack[mach->sp + 2]._float = _slang_library_noise3 (stack[mach->sp]._float,
443
 
                                stack[mach->sp + 1]._float, stack[mach->sp + 2]._float);
444
 
                        mach->sp += 2;
445
 
                        break;
446
 
                case slang_asm_float_noise4:
447
 
                        stack[mach->sp + 3]._float = _slang_library_noise4 (stack[mach->sp]._float,
448
 
                                stack[mach->sp + 1]._float, stack[mach->sp + 2]._float, stack[mach->sp + 3]._float);
449
 
                        mach->sp += 3;
450
 
                        break;
451
 
                case slang_asm_int_to_float:
452
 
                        break;
453
 
                case slang_asm_int_to_addr:
454
 
                        stack[mach->sp]._addr = (GLuint) (GLint) stack[mach->sp]._float;
455
 
                        break;
456
 
                case slang_asm_addr_copy:
457
 
                        mach->mem[stack[mach->sp + 1]._addr / 4]._addr = stack[mach->sp]._addr;
458
 
                        mach->sp++;
459
 
                        break;
460
 
                case slang_asm_addr_push:
461
 
                case slang_asm_global_addr:
462
 
                        mach->sp--;
463
 
                        stack[mach->sp]._addr = a->param[0];
464
 
                        break;
465
 
                case slang_asm_addr_deref:
466
 
                        stack[mach->sp]._addr = mach->mem[stack[mach->sp]._addr / 4]._addr;
467
 
                        break;
468
 
                case slang_asm_addr_add:
469
 
                        stack[mach->sp + 1]._addr += stack[mach->sp]._addr;
470
 
                        mach->sp++;
471
 
                        break;
472
 
                case slang_asm_addr_multiply:
473
 
                        stack[mach->sp + 1]._addr *= stack[mach->sp]._addr;
474
 
                        mach->sp++;
475
 
                        break;
476
 
                case slang_asm_vec4_tex1d:
477
 
                        _slang_library_tex1d (stack[mach->sp]._float, stack[mach->sp + 1]._float,
478
 
                                stack[mach->sp + 2]._float, &mach->mem[stack[mach->sp + 3]._addr / 4]._float);
479
 
                        mach->sp += 3;
480
 
                        break;
481
 
                case slang_asm_vec4_tex2d:
482
 
                        _slang_library_tex2d (stack[mach->sp]._float, stack[mach->sp + 1]._float,
483
 
                                stack[mach->sp + 2]._float, stack[mach->sp + 3]._float,
484
 
                                &mach->mem[stack[mach->sp + 4]._addr / 4]._float);
485
 
                        mach->sp += 4;
486
 
                        break;
487
 
                case slang_asm_vec4_tex3d:
488
 
                        _slang_library_tex3d (stack[mach->sp]._float, stack[mach->sp + 1]._float,
489
 
                                stack[mach->sp + 2]._float, stack[mach->sp + 3]._float, stack[mach->sp + 4]._float,
490
 
                                &mach->mem[stack[mach->sp + 5]._addr / 4]._float);
491
 
                        mach->sp += 5;
492
 
                        break;
493
 
                case slang_asm_vec4_texcube:
494
 
                        _slang_library_texcube (stack[mach->sp]._float, stack[mach->sp + 1]._float,
495
 
                                stack[mach->sp + 2]._float, stack[mach->sp + 3]._float, stack[mach->sp + 4]._float,
496
 
                                &mach->mem[stack[mach->sp + 5]._addr / 4]._float);
497
 
                        mach->sp += 5;
498
 
                        break;
499
 
                case slang_asm_vec4_shad1d:
500
 
                        _slang_library_shad1d (stack[mach->sp]._float, stack[mach->sp + 1]._float,
501
 
                                stack[mach->sp + 2]._float, stack[mach->sp + 3]._float, stack[mach->sp + 4]._float,
502
 
                                &mach->mem[stack[mach->sp + 5]._addr / 4]._float);
503
 
                        mach->sp += 5;
504
 
                        break;
505
 
                case slang_asm_vec4_shad2d:
506
 
                        _slang_library_shad2d (stack[mach->sp]._float, stack[mach->sp + 1]._float,
507
 
                                stack[mach->sp + 2]._float, stack[mach->sp + 3]._float, stack[mach->sp + 4]._float,
508
 
                                &mach->mem[stack[mach->sp + 5]._addr / 4]._float);
509
 
                        mach->sp += 5;
510
 
                        break;
511
 
                case slang_asm_jump:
512
 
                        mach->ip = a->param[0];
513
 
                        break;
514
 
                case slang_asm_jump_if_zero:
515
 
                        if (stack[mach->sp]._float == 0.0f)
516
 
                                mach->ip = a->param[0];
517
 
                        mach->sp++;
518
 
                        break;
519
 
                case slang_asm_enter:
520
 
                        mach->sp--;
521
 
                        stack[mach->sp]._addr = mach->bp;
522
 
                        mach->bp = mach->sp + a->param[0] / 4;
523
 
                        break;
524
 
                case slang_asm_leave:
525
 
                        mach->bp = stack[mach->sp]._addr;
526
 
                        mach->sp++;
527
 
                        break;
528
 
                case slang_asm_local_alloc:
529
 
                        mach->sp -= a->param[0] / 4;
530
 
                        break;
531
 
                case slang_asm_local_free:
532
 
                        mach->sp += a->param[0] / 4;
533
 
                        break;
534
 
                case slang_asm_local_addr:
535
 
                        mach->sp--;
536
 
                        stack[mach->sp]._addr = SLANG_MACHINE_GLOBAL_SIZE * 4 + mach->bp * 4 - 
537
 
                                (a->param[0] + a->param[1]) + 4;
538
 
                        break;
539
 
                case slang_asm_call:
540
 
                        mach->sp--;
541
 
                        stack[mach->sp]._addr = mach->ip;
542
 
                        mach->ip = a->param[0];
543
 
                        break;
544
 
                case slang_asm_return:
545
 
                        mach->ip = stack[mach->sp]._addr;
546
 
                        mach->sp++;
547
 
                        break;
548
 
                case slang_asm_discard:
549
 
                        mach->kill = 1;
550
 
                        break;
551
 
                case slang_asm_exit:
552
 
                        mach->exit = 1;
553
 
                        break;
554
 
                /* mesa-specific extensions */
555
 
                case slang_asm_float_print:
556
 
                        _mesa_printf ("slang print: %f\n", stack[mach->sp]._float);
557
 
         ensure_infolog_created (&mach->infolog);
558
 
         slang_info_log_print (mach->infolog, "%f", stack[mach->sp]._float);
559
 
                        break;
560
 
                case slang_asm_int_print:
561
 
                        _mesa_printf ("slang print: %d\n", (GLint) stack[mach->sp]._float);
562
 
         ensure_infolog_created (&mach->infolog);
563
 
         slang_info_log_print (mach->infolog, "%d", (GLint) (stack[mach->sp]._float));
564
 
                        break;
565
 
                case slang_asm_bool_print:
566
 
                        _mesa_printf ("slang print: %s\n", (GLint) stack[mach->sp]._float ? "true" : "false");
567
 
         ensure_infolog_created (&mach->infolog);
568
 
         slang_info_log_print (mach->infolog, "%s",
569
 
                               (GLint) (stack[mach->sp]._float) ? "true" : "false");
570
 
                        break;
571
 
                default:
572
 
                        assert (0);
573
 
                }
574
 
        }
575
 
 
576
 
#if DEBUG_SLANG
577
 
        if (f != NULL)
578
 
                fclose (f);
579
 
#endif
580
 
 
581
 
        return 1;
 
361
   if (mach->x86.compiled_func != NULL) {
 
362
      mach->x86.compiled_func(mach);
 
363
      return GL_TRUE;
 
364
   }
 
365
#endif
 
366
 
 
367
   stack = mach->mem + SLANG_MACHINE_GLOBAL_SIZE;
 
368
 
 
369
   while (!mach->exit) {
 
370
      const slang_assembly *a = &file->code[mach->ip];
 
371
 
 
372
#if DEBUG_SLANG
 
373
      if (f != NULL && a->type != slang_asm_none) {
 
374
         unsigned int i;
 
375
 
 
376
         dump_instruction(f, file->code + mach->ip, mach->ip);
 
377
         fprintf(f, "\t\tsp=%u bp=%u\n", mach->sp, mach->bp);
 
378
         for (i = mach->sp; i < SLANG_MACHINE_STACK_SIZE; i++)
 
379
            fprintf(f, "\t%.5u\t%6f\t%u\n", i, stack[i]._float,
 
380
                    stack[i]._addr);
 
381
         fflush(f);
 
382
      }
 
383
#endif
 
384
 
 
385
      mach->ip++;
 
386
 
 
387
      switch (a->type) {
 
388
         /* core */
 
389
      case slang_asm_none:
 
390
         break;
 
391
      case slang_asm_float_copy:
 
392
      case slang_asm_int_copy:
 
393
      case slang_asm_bool_copy:
 
394
         /* store top value on stack to memory */
 
395
         {
 
396
            GLuint address
 
397
               = (stack[mach->sp + a->param[0] / 4]._addr + a->param[1]) / 4;
 
398
            GLfloat value = stack[mach->sp]._float;
 
399
            mach->mem[address]._float = value;
 
400
         }
 
401
         mach->sp++;
 
402
         break;
 
403
      case slang_asm_float_move:
 
404
      case slang_asm_int_move:
 
405
      case slang_asm_bool_move:
 
406
         stack[mach->sp + a->param[0] / 4]._float =
 
407
            stack[mach->sp +
 
408
                  (stack[mach->sp]._addr + a->param[1]) / 4]._float;
 
409
         break;
 
410
      case slang_asm_float_push:
 
411
      case slang_asm_int_push:
 
412
      case slang_asm_bool_push:
 
413
         /* push float/int/bool literal onto stop of stack */
 
414
         mach->sp--;
 
415
         stack[mach->sp]._float = a->literal;
 
416
         break;
 
417
      case slang_asm_float_deref:
 
418
      case slang_asm_int_deref:
 
419
      case slang_asm_bool_deref:
 
420
         /* load value from memory, replace stop of stack with it */
 
421
         stack[mach->sp]._float = mach->mem[stack[mach->sp]._addr / 4]._float;
 
422
         break;
 
423
      case slang_asm_float_add:
 
424
         /* pop two top floats, push sum */
 
425
         stack[mach->sp + 1]._float += stack[mach->sp]._float;
 
426
         mach->sp++;
 
427
         break;
 
428
      case slang_asm_float_multiply:
 
429
         stack[mach->sp + 1]._float *= stack[mach->sp]._float;
 
430
         mach->sp++;
 
431
         break;
 
432
      case slang_asm_float_divide:
 
433
         stack[mach->sp + 1]._float /= stack[mach->sp]._float;
 
434
         mach->sp++;
 
435
         break;
 
436
      case slang_asm_float_negate:
 
437
         stack[mach->sp]._float = -stack[mach->sp]._float;
 
438
         break;
 
439
      case slang_asm_float_less:
 
440
         stack[mach->sp + 1]._float =
 
441
            (stack[mach->sp + 1]._float < stack[mach->sp]._float)
 
442
            ? (GLfloat) 1 : (GLfloat) 0;
 
443
         mach->sp++;
 
444
         break;
 
445
      case slang_asm_float_equal_exp:
 
446
         stack[mach->sp + 1]._float =
 
447
            (stack[mach->sp + 1]._float == stack[mach->sp]._float)
 
448
            ? (GLfloat) 1 : (GLfloat) 0;
 
449
         mach->sp++;
 
450
         break;
 
451
      case slang_asm_float_equal_int:
 
452
         /* pop top two values, compare, push 0 or 1 */
 
453
         mach->sp--;
 
454
         stack[mach->sp]._float =
 
455
            (stack[mach->sp + 1 + a->param[0] / 4]._float ==
 
456
             stack[mach->sp + 1 + a->param[1] / 4]._float)
 
457
            ? (GLfloat) 1 : (GLfloat) 0;
 
458
         break;
 
459
      case slang_asm_float_to_int:
 
460
         stack[mach->sp]._float = (GLfloat) (GLint) stack[mach->sp]._float;
 
461
         break;
 
462
      case slang_asm_float_sine:
 
463
         stack[mach->sp]._float = (GLfloat) _mesa_sin(stack[mach->sp]._float);
 
464
         break;
 
465
      case slang_asm_float_arcsine:
 
466
         stack[mach->sp]._float = _mesa_asinf(stack[mach->sp]._float);
 
467
         break;
 
468
      case slang_asm_float_arctan:
 
469
         stack[mach->sp]._float = _mesa_atanf(stack[mach->sp]._float);
 
470
         break;
 
471
      case slang_asm_float_power:
 
472
         stack[mach->sp + 1]._float = (GLfloat)
 
473
            _mesa_pow(stack[mach->sp + 1]._float, stack[mach->sp]._float);
 
474
         mach->sp++;
 
475
         break;
 
476
      case slang_asm_float_log2:
 
477
         stack[mach->sp]._float = LOG2(stack[mach->sp]._float);
 
478
         break;
 
479
      case slang_asm_float_floor:
 
480
         stack[mach->sp]._float = FLOORF(stack[mach->sp]._float);
 
481
         break;
 
482
      case slang_asm_float_ceil:
 
483
         stack[mach->sp]._float = CEILF(stack[mach->sp]._float);
 
484
         break;
 
485
      case slang_asm_float_noise1:
 
486
         stack[mach->sp]._float =
 
487
            _slang_library_noise1(stack[mach->sp]._float);
 
488
         break;
 
489
      case slang_asm_float_noise2:
 
490
         stack[mach->sp + 1]._float =
 
491
            _slang_library_noise2(stack[mach->sp]._float,
 
492
                                  stack[mach->sp + 1]._float);
 
493
         mach->sp++;
 
494
         break;
 
495
      case slang_asm_float_noise3:
 
496
         stack[mach->sp + 2]._float =
 
497
            _slang_library_noise3(stack[mach->sp]._float,
 
498
                                  stack[mach->sp + 1]._float,
 
499
                                  stack[mach->sp + 2]._float);
 
500
         mach->sp += 2;
 
501
         break;
 
502
      case slang_asm_float_noise4:
 
503
         stack[mach->sp + 3]._float =
 
504
            _slang_library_noise4(stack[mach->sp]._float,
 
505
                                  stack[mach->sp + 1]._float,
 
506
                                  stack[mach->sp + 2]._float,
 
507
                                  stack[mach->sp + 3]._float);
 
508
         mach->sp += 3;
 
509
         break;
 
510
      case slang_asm_int_to_float:
 
511
         break;
 
512
      case slang_asm_int_to_addr:
 
513
         stack[mach->sp]._addr = (GLuint) (GLint) stack[mach->sp]._float;
 
514
         break;
 
515
      case slang_asm_addr_copy:
 
516
         mach->mem[stack[mach->sp + 1]._addr / 4]._addr =
 
517
            stack[mach->sp]._addr;
 
518
         mach->sp++;
 
519
         break;
 
520
      case slang_asm_addr_push:
 
521
      case slang_asm_global_addr:
 
522
         mach->sp--;
 
523
         stack[mach->sp]._addr = a->param[0];
 
524
         break;
 
525
      case slang_asm_addr_deref:
 
526
         stack[mach->sp]._addr = mach->mem[stack[mach->sp]._addr / 4]._addr;
 
527
         break;
 
528
      case slang_asm_addr_add:
 
529
         stack[mach->sp + 1]._addr += stack[mach->sp]._addr;
 
530
         mach->sp++;
 
531
         break;
 
532
      case slang_asm_addr_multiply:
 
533
         stack[mach->sp + 1]._addr *= stack[mach->sp]._addr;
 
534
         mach->sp++;
 
535
         break;
 
536
      case slang_asm_vec4_tex1d:
 
537
         _slang_library_tex1d(stack[mach->sp]._float,
 
538
                              stack[mach->sp + 1]._float,
 
539
                              stack[mach->sp + 2]._float,
 
540
                              &mach->mem[stack[mach->sp + 3]._addr /
 
541
                                         4]._float);
 
542
         mach->sp += 3;
 
543
         break;
 
544
      case slang_asm_vec4_tex2d:
 
545
         _slang_library_tex2d(stack[mach->sp]._float,
 
546
                              stack[mach->sp + 1]._float,
 
547
                              stack[mach->sp + 2]._float,
 
548
                              stack[mach->sp + 3]._float,
 
549
                              &mach->mem[stack[mach->sp + 4]._addr /
 
550
                                         4]._float);
 
551
         mach->sp += 4;
 
552
         break;
 
553
      case slang_asm_vec4_tex3d:
 
554
         _slang_library_tex3d(stack[mach->sp]._float,
 
555
                              stack[mach->sp + 1]._float,
 
556
                              stack[mach->sp + 2]._float,
 
557
                              stack[mach->sp + 3]._float,
 
558
                              stack[mach->sp + 4]._float,
 
559
                              &mach->mem[stack[mach->sp + 5]._addr /
 
560
                                         4]._float);
 
561
         mach->sp += 5;
 
562
         break;
 
563
      case slang_asm_vec4_texcube:
 
564
         _slang_library_texcube(stack[mach->sp]._float,
 
565
                                stack[mach->sp + 1]._float,
 
566
                                stack[mach->sp + 2]._float,
 
567
                                stack[mach->sp + 3]._float,
 
568
                                stack[mach->sp + 4]._float,
 
569
                                &mach->mem[stack[mach->sp + 5]._addr /
 
570
                                           4]._float);
 
571
         mach->sp += 5;
 
572
         break;
 
573
      case slang_asm_vec4_shad1d:
 
574
         _slang_library_shad1d(stack[mach->sp]._float,
 
575
                               stack[mach->sp + 1]._float,
 
576
                               stack[mach->sp + 2]._float,
 
577
                               stack[mach->sp + 3]._float,
 
578
                               stack[mach->sp + 4]._float,
 
579
                               &mach->mem[stack[mach->sp + 5]._addr /
 
580
                                          4]._float);
 
581
         mach->sp += 5;
 
582
         break;
 
583
      case slang_asm_vec4_shad2d:
 
584
         _slang_library_shad2d(stack[mach->sp]._float,
 
585
                               stack[mach->sp + 1]._float,
 
586
                               stack[mach->sp + 2]._float,
 
587
                               stack[mach->sp + 3]._float,
 
588
                               stack[mach->sp + 4]._float,
 
589
                               &mach->mem[stack[mach->sp + 5]._addr /
 
590
                                          4]._float);
 
591
         mach->sp += 5;
 
592
         break;
 
593
      case slang_asm_jump:
 
594
         mach->ip = a->param[0];
 
595
         break;
 
596
      case slang_asm_jump_if_zero:
 
597
         if (stack[mach->sp]._float == 0.0f)
 
598
            mach->ip = a->param[0];
 
599
         mach->sp++;
 
600
         break;
 
601
      case slang_asm_enter:
 
602
         mach->sp--;
 
603
         stack[mach->sp]._addr = mach->bp;
 
604
         mach->bp = mach->sp + a->param[0] / 4;
 
605
         break;
 
606
      case slang_asm_leave:
 
607
         mach->bp = stack[mach->sp]._addr;
 
608
         mach->sp++;
 
609
         break;
 
610
      case slang_asm_local_alloc:
 
611
         mach->sp -= a->param[0] / 4;
 
612
         break;
 
613
      case slang_asm_local_free:
 
614
         mach->sp += a->param[0] / 4;
 
615
         break;
 
616
      case slang_asm_local_addr:
 
617
         mach->sp--;
 
618
         stack[mach->sp]._addr =
 
619
            SLANG_MACHINE_GLOBAL_SIZE * 4 + mach->bp * 4 - (a->param[0] +
 
620
                                                            a->param[1]) + 4;
 
621
         break;
 
622
      case slang_asm_call:
 
623
         mach->sp--;
 
624
         stack[mach->sp]._addr = mach->ip;
 
625
         mach->ip = a->param[0];
 
626
         break;
 
627
      case slang_asm_return:
 
628
         mach->ip = stack[mach->sp]._addr;
 
629
         mach->sp++;
 
630
         break;
 
631
      case slang_asm_discard:
 
632
         mach->kill = GL_TRUE;
 
633
         break;
 
634
      case slang_asm_exit:
 
635
         mach->exit = GL_TRUE;
 
636
         break;
 
637
         /* GL_MESA_shader_debug */
 
638
      case slang_asm_float_print:
 
639
         _mesa_printf("slang print: %f\n", stack[mach->sp]._float);
 
640
         ensure_infolog_created(&mach->infolog);
 
641
         slang_info_log_print(mach->infolog, "%f", stack[mach->sp]._float);
 
642
         break;
 
643
      case slang_asm_int_print:
 
644
         _mesa_printf("slang print: %d\n", (GLint) stack[mach->sp]._float);
 
645
         ensure_infolog_created(&mach->infolog);
 
646
         slang_info_log_print(mach->infolog, "%d",
 
647
                              (GLint) (stack[mach->sp]._float));
 
648
         break;
 
649
      case slang_asm_bool_print:
 
650
         _mesa_printf("slang print: %s\n",
 
651
                      (GLint) stack[mach->sp]._float ? "true" : "false");
 
652
         ensure_infolog_created(&mach->infolog);
 
653
         slang_info_log_print(mach->infolog, "%s",
 
654
                              (GLint) (stack[mach->sp].
 
655
                                       _float) ? "true" : "false");
 
656
         break;
 
657
         /* vec4 */
 
658
      case slang_asm_float_to_vec4:
 
659
         /* [vec4] | float > [vec4] */
 
660
         {
 
661
            GLuint da = stack[mach->sp + 1]._addr;
 
662
            mach->mem[da / 4]._float = stack[mach->sp]._float;
 
663
            mach->sp++;
 
664
         }
 
665
         break;
 
666
      case slang_asm_vec4_add:
 
667
         /* [vec4] | vec4 > [vec4] */
 
668
         {
 
669
            GLuint da = stack[mach->sp + 4]._addr;
 
670
            mach->mem[da / 4]._float += stack[mach->sp]._float;
 
671
            mach->mem[(da + 4) / 4]._float += stack[mach->sp + 1]._float;
 
672
            mach->mem[(da + 8) / 4]._float += stack[mach->sp + 2]._float;
 
673
            mach->mem[(da + 12) / 4]._float += stack[mach->sp + 3]._float;
 
674
            mach->sp += 4;
 
675
         }
 
676
         break;
 
677
      case slang_asm_vec4_subtract:
 
678
         /* [vec4] | vec4 > [vec4] */
 
679
         {
 
680
            GLuint da = stack[mach->sp + 4]._addr;
 
681
            mach->mem[da / 4]._float -= stack[mach->sp]._float;
 
682
            mach->mem[(da + 4) / 4]._float -= stack[mach->sp + 1]._float;
 
683
            mach->mem[(da + 8) / 4]._float -= stack[mach->sp + 2]._float;
 
684
            mach->mem[(da + 12) / 4]._float -= stack[mach->sp + 3]._float;
 
685
            mach->sp += 4;
 
686
         }
 
687
         break;
 
688
      case slang_asm_vec4_multiply:
 
689
         /* [vec4] | vec4 > [vec4] */
 
690
         {
 
691
            GLuint da = stack[mach->sp + 4]._addr;
 
692
            mach->mem[da / 4]._float *= stack[mach->sp]._float;
 
693
            mach->mem[(da + 4) / 4]._float *= stack[mach->sp + 1]._float;
 
694
            mach->mem[(da + 8) / 4]._float *= stack[mach->sp + 2]._float;
 
695
            mach->mem[(da + 12) / 4]._float *= stack[mach->sp + 3]._float;
 
696
            mach->sp += 4;
 
697
         }
 
698
         break;
 
699
      case slang_asm_vec4_divide:
 
700
         /* [vec4] | vec4 > [vec4] */
 
701
         {
 
702
            GLuint da = stack[mach->sp + 4]._addr;
 
703
            mach->mem[da / 4]._float /= stack[mach->sp]._float;
 
704
            mach->mem[(da + 4) / 4]._float /= stack[mach->sp + 1]._float;
 
705
            mach->mem[(da + 8) / 4]._float /= stack[mach->sp + 2]._float;
 
706
            mach->mem[(da + 12) / 4]._float /= stack[mach->sp + 3]._float;
 
707
            mach->sp += 4;
 
708
         }
 
709
         break;
 
710
      case slang_asm_vec4_negate:
 
711
         /* [vec4] > [vec4] */
 
712
         {
 
713
            GLuint da = stack[mach->sp]._addr;
 
714
            mach->mem[da / 4]._float = -mach->mem[da / 4]._float;
 
715
            mach->mem[(da + 4) / 4]._float = -mach->mem[(da + 4) / 4]._float;
 
716
            mach->mem[(da + 8) / 4]._float = -mach->mem[(da + 8) / 4]._float;
 
717
            mach->mem[(da + 12) / 4]._float =
 
718
               -mach->mem[(da + 12) / 4]._float;
 
719
         }
 
720
         break;
 
721
      case slang_asm_vec4_dot:
 
722
         /* [vec4] | vec4 > [float] */
 
723
         {
 
724
            GLuint da = stack[mach->sp + 4]._addr;
 
725
            mach->mem[da / 4]._float =
 
726
               mach->mem[da / 4]._float * stack[mach->sp]._float +
 
727
               mach->mem[(da + 4) / 4]._float * stack[mach->sp + 1]._float +
 
728
               mach->mem[(da + 8) / 4]._float * stack[mach->sp + 2]._float +
 
729
               mach->mem[(da + 12) / 4]._float * stack[mach->sp + 3]._float;
 
730
            mach->sp += 4;
 
731
         }
 
732
         break;
 
733
      case slang_asm_vec4_copy:
 
734
         /* [vec4] | vec4 > [vec4] */
 
735
         {
 
736
            GLuint da = stack[mach->sp + a->param[0] / 4]._addr + a->param[1];
 
737
            mach->mem[da / 4]._float = stack[mach->sp]._float;
 
738
            mach->mem[(da + 4) / 4]._float = stack[mach->sp + 1]._float;
 
739
            mach->mem[(da + 8) / 4]._float = stack[mach->sp + 2]._float;
 
740
            mach->mem[(da + 12) / 4]._float = stack[mach->sp + 3]._float;
 
741
            mach->sp += 4;
 
742
         }
 
743
         break;
 
744
      case slang_asm_vec4_deref:
 
745
         /* [vec4] > vec4 */
 
746
         {
 
747
            GLuint sa = stack[mach->sp]._addr;
 
748
            mach->sp -= 3;
 
749
            stack[mach->sp]._float = mach->mem[sa / 4]._float;
 
750
            stack[mach->sp + 1]._float = mach->mem[(sa + 4) / 4]._float;
 
751
            stack[mach->sp + 2]._float = mach->mem[(sa + 8) / 4]._float;
 
752
            stack[mach->sp + 3]._float = mach->mem[(sa + 12) / 4]._float;
 
753
         }
 
754
         break;
 
755
      case slang_asm_vec4_equal_int:
 
756
         {
 
757
            GLuint sp0 = mach->sp + a->param[0] / 4;
 
758
            GLuint sp1 = mach->sp + a->param[1] / 4;
 
759
            mach->sp--;
 
760
            if (stack[sp0]._float == stack[sp1]._float &&
 
761
                stack[sp0 + 1]._float == stack[sp1 + 1]._float &&
 
762
                stack[sp0 + 2]._float == stack[sp1 + 2]._float &&
 
763
                stack[sp0 + 3]._float == stack[sp1 + 3]._float) {
 
764
               stack[mach->sp]._float = 1.0f;
 
765
            }
 
766
            else {
 
767
               stack[mach->sp]._float = 0.0f;
 
768
            }
 
769
         }
 
770
         break;
 
771
      default:
 
772
         _mesa_problem(NULL, "bad slang opcode 0x%x", a->type);
 
773
         return GL_FALSE;
 
774
      }
 
775
   }
 
776
 
 
777
#if DEBUG_SLANG
 
778
   if (f != NULL)
 
779
      fclose(f);
 
780
#endif
 
781
 
 
782
   return GL_TRUE;
582
783
}
583