?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix yet another bug in GC, in which the instruction pointer was not
[panda.git] / src / st-processor.c
blob8548f8e76f60818aa83e5810796cd3093d9589ed
1
2 #include "st-types.h"
3 #include "st-compiler.h"
4 #include "st-universe.h"
5 #include "st-dictionary.h"
6 #include "st-symbol.h"
7 #include "st-object.h"
8 #include "st-behavior.h"
9 #include "st-context.h"
10 #include "st-primitives.h"
11 #include "st-method.h"
12 #include "st-array.h"
13 #include "st-association.h"
14
15 #include <stdlib.h>
16 #include <setjmp.h>
17
18 static st_oop
19 method_context_new (st_processor *pr)
20 {
21 st_oop context;
22 int stack_size;
23 st_oop *stack;
24 bool large;
25
26 large = st_method_get_large_context (pr->new_method);
27 stack_size = large ? 32 : 12;
28
29 context = st_memory_allocate_context (large);
30
31 ST_CONTEXT_PART_SENDER (context) = pr->context;
32 ST_CONTEXT_PART_IP (context) = st_smi_new (0);
33 ST_CONTEXT_PART_SP (context) = st_smi_new (0);
34 ST_METHOD_CONTEXT_RECEIVER (context) = pr->message_receiver;
35 ST_METHOD_CONTEXT_METHOD (context) = pr->new_method;
36
37 stack = ST_METHOD_CONTEXT (context)->stack;
38 for (st_uint i=0; i < stack_size; i++)
39 stack[i] = st_nil;
40
41 return context;
42 }
43
44 static st_oop
45 block_context_new (st_processor *pr, st_uint initial_ip, st_uint argcount)
46 {
47 st_oop home;
48 st_oop context;
49 st_oop method;
50 st_oop *stack;
51 st_uint stack_size;
52
53 stack_size = 32;
54
55 context = st_memory_allocate (ST_SIZE_OOPS (struct st_block_context) + stack_size);
56 st_object_initialize_header (context, st_block_context_class);
57 st_object_set_large_context (context, true);
58
59 if (ST_OBJECT_CLASS (pr->context) == st_block_context_class)
60 home = ST_BLOCK_CONTEXT_HOME (pr->context);
61 else
62 home = pr->context;
63
64 ST_CONTEXT_PART_SENDER (context) = st_nil;
65 ST_CONTEXT_PART_IP (context) = st_smi_new (0);
66 ST_CONTEXT_PART_SP (context) = st_smi_new (0);
67
68 ST_BLOCK_CONTEXT_INITIALIP (context) = st_smi_new (initial_ip);
69 ST_BLOCK_CONTEXT_ARGCOUNT (context) = st_smi_new (argcount);
70 ST_BLOCK_CONTEXT_CALLER (context) = st_nil;
71 ST_BLOCK_CONTEXT_HOME (context) = home;
72
73 stack = ST_BLOCK_CONTEXT (context)->stack;
74 for (st_uint i=0; i < stack_size; i++)
75 stack[i] = st_nil;
76
77 return context;
78 }
79
80 static void
81 create_actual_message (st_processor *pr)
82 {
83 st_oop *elements;
84 st_oop array;
85
86 array = st_object_new_arrayed (st_array_class, pr->message_argcount);
87 elements = st_array_elements (array);
88 for (st_uint i = 0; i < pr->message_argcount; i++)
89 elements[i] = pr->stack[pr_sp - pr->message_argcount + i];
90
91 pr_sp -= pr->message_argcount;
92
93 ST_STACK_PUSH (pr, st_message_new (pr->message_selector, array));
94
95 pr->message_selector = st_selector_doesNotUnderstand;
96 pr->message_argcount = 1;
97 }
98
99 static inline st_oop
100 lookup_method (st_processor *pr, st_oop class)
101 {
102 st_oop method;
103 st_oop parent = class;
104 st_uint index;
105
106 index = ST_METHOD_CACHE_HASH (class, pr->message_selector);
107
108 if (pr->method_cache[index].class == class &&
109 pr->method_cache[index].selector == pr->message_selector)
110 return pr->method_cache[index].method;
111
112 while (parent != st_nil) {
113 method = st_dictionary_at (ST_BEHAVIOR_METHOD_DICTIONARY (parent), pr->message_selector);
114 if (method != st_nil) {
115 index = ST_METHOD_CACHE_HASH (parent, pr->message_selector);
116 pr->method_cache[index].class = class;
117 pr->method_cache[index].selector = pr->message_selector;
118 pr->method_cache[index].method = method;
119 return method;
120 }
121 parent = ST_BEHAVIOR_SUPERCLASS (parent);
122 }
123
124 if (pr->message_selector == st_selector_doesNotUnderstand) {
125 fprintf (stderr, "no method found for #doesNotUnderstand:");
126 exit(1);
127 }
128
129 create_actual_message (pr);
130
131 return lookup_method (pr, class);
132 }
133
134 st_oop
135 st_processor_lookup_method (st_processor *pr, st_oop class)
136 {
137 return lookup_method (pr, class);
138 }
139
140 /*
141 * Creates a new method context. Parameterised by
142 * @sender, @receiver, @method, and @argcount
143 *
144 * Message arguments are copied into the new context's temporary
145 * frame. Receiver and arguments are then popped off the stack.
146 *
147 */
148 static inline void
149 activate_method (st_processor *pr)
150 {
151 st_oop context;
152 st_oop *arguments;
153
154 context = method_context_new (pr);
155
156 arguments = ST_METHOD_CONTEXT_TEMPORARY_FRAME (context);
157 for (st_uint i = 0; i < pr->message_argcount; i++)
158 arguments[i] = pr->stack[pr_sp - pr->message_argcount + i];
159
160 pr_sp -= pr->message_argcount + 1;
161
162 st_processor_set_active_context (pr, context);
163 }
164
165 void
166 st_processor_execute_method (st_processor *pr)
167 {
168 st_uint primitive_index;
169 st_method_flags flags;
170
171 flags = st_method_get_flags (pr->new_method);
172 if (flags == ST_METHOD_PRIMITIVE) {
173 primitive_index = st_method_get_primitive_index (pr->new_method);
174 pr->success = true;
175 st_primitives[primitive_index].func (pr);
176 if (ST_LIKELY (pr->success))
177 return;
178 }
179
180 activate_method (pr);
181 }
182
183
184 void
185 st_processor_set_active_context (st_processor *pr,
186 st_oop context)
187 {
188 st_oop home;
189
190 /* save executation state of active context */
191 if (pr->context != st_nil) {
192 ST_CONTEXT_PART_IP (pr->context) = st_smi_new (pr_ip - st_method_bytecode_bytes (pr->method));
193 ST_CONTEXT_PART_SP (pr->context) = st_smi_new (pr_sp);
194 }
195
196 if (st_object_class (context) == st_block_context_class) {
197
198 home = ST_BLOCK_CONTEXT_HOME (context);
199
200 pr->method = ST_METHOD_CONTEXT_METHOD (home);
201 pr->receiver = ST_METHOD_CONTEXT_RECEIVER (home);
202 pr->literals = st_array_elements (ST_METHOD_LITERALS (pr->method));
203 pr->temps = ST_METHOD_CONTEXT_TEMPORARY_FRAME (home);
204 pr->stack = ST_BLOCK_CONTEXT_STACK (context);
205 } else {
206 pr->method = ST_METHOD_CONTEXT_METHOD (context);
207 pr->receiver = ST_METHOD_CONTEXT_RECEIVER (context);
208 pr->literals = st_array_elements (ST_METHOD_LITERALS (pr->method));
209 pr->temps = ST_METHOD_CONTEXT_TEMPORARY_FRAME (context);
210 pr->stack = ST_METHOD_CONTEXT_STACK (context);
211 }
212
213 pr->context = context;
214 pr_sp = st_smi_value (ST_CONTEXT_PART_SP (context));
215 pr_ip = st_method_bytecode_bytes (pr->method) + st_smi_value (ST_CONTEXT_PART_IP (context));
216 pr->bytecode = st_method_bytecode_bytes (pr->method);
217
218 }
219
220 void
221 st_processor_prologue (st_processor *pr)
222 {
223 if (st_verbose_mode ()) {
224 fprintf (stderr, "** gc: totalPauseTime: %.6fs\n", st_timespec_to_double_seconds (&memory->total_pause_time));
225 }
226 }
227
228 void
229 st_processor_send_selector (st_processor *pr,
230 st_oop selector,
231 st_uint argcount)
232 {
233 st_oop method;
234 st_uint primitive_index;
235 st_method_flags flags;
236
237 pr->message_argcount = argcount;
238 pr->message_receiver = pr->stack[pr_sp - argcount - 1];
239 pr->message_selector = selector;
240
241 pr->new_method = st_processor_lookup_method (pr, st_object_class (pr->message_receiver));
242
243 flags = st_method_get_flags (pr->new_method);
244 if (flags == ST_METHOD_PRIMITIVE) {
245 primitive_index = st_method_get_primitive_index (pr->new_method);
246 pr->success = true;
247 st_primitives[primitive_index].func (pr);
248 if (ST_LIKELY (pr->success))
249 return;
250 }
251
252 activate_method (pr);
253 }
254
255 #define SEND_SELECTOR(pr, selector, argcount) \
256 st_processor_send_selector (pr, selector, argcount); \
257
258 #define ACTIVATE_CONTEXT(pr, context) \
259 st_processor_set_active_context (pr, context); \
260
261 #define ACTIVATE_METHOD(pr) \
262 activate_method (pr); \
263
264 #define EXECUTE_PRIMITIVE(pr, index) \
265 pr->success = true; \
266 st_primitives[index].func (pr);
267
268 #define SEND_TEMPLATE(pr) \
269 st_uint prim; \
270 st_method_flags flags; \
271 \
272 pr_ip += 1; \
273 \
274 pr->new_method = st_processor_lookup_method (pr, st_object_class (pr->message_receiver));\
275 \
276 flags = st_method_get_flags (pr->new_method); \
277 if (flags == ST_METHOD_PRIMITIVE) { \
278 prim = st_method_get_primitive_index (pr->new_method); \
279 \
280 EXECUTE_PRIMITIVE (pr, prim); \
281 if (ST_LIKELY (pr->success)) \
282 NEXT (); \
283 } \
284 \
285 ACTIVATE_METHOD (pr);
286
287
288 #ifdef __GNUC__
289 #define I_HAS_COMPUTED_GOTO
290 #endif
291
292 #ifdef I_HAS_COMPUTED_GOTO
293 #define SWITCH(ip) \
294 static const st_pointer labels[] = \
295 { \
296 NULL, \
297 && PUSH_TEMP, && PUSH_INSTVAR, \
298 && PUSH_LITERAL_CONST, && PUSH_LITERAL_VAR, \
299 \
300 && STORE_LITERAL_VAR, && STORE_TEMP, && STORE_INSTVAR, \
301 && STORE_POP_LITERAL_VAR, && STORE_POP_TEMP, && STORE_POP_INSTVAR, \
302 \
303 && PUSH_SELF, && PUSH_NIL, && PUSH_TRUE, && PUSH_FALSE, && PUSH_INTEGER, \
304 \
305 && RETURN_STACK_TOP, && BLOCK_RETURN, \
306 && POP_STACK_TOP, && DUPLICATE_STACK_TOP, \
307 \
308 && PUSH_ACTIVE_CONTEXT, && BLOCK_COPY, \
309 \
310 && JUMP_TRUE, && JUMP_FALSE, && JUMP, \
311 \
312 && SEND, && SEND_SUPER, \
313 \
314 && SEND_PLUS, && SEND_MINUS, \
315 && SEND_LT, && SEND_GT, \
316 && SEND_LE, && SEND_GE, \
317 && SEND_EQ, && SEND_NE, \
318 && SEND_MUL, && SEND_DIV, \
319 && SEND_MOD, && SEND_BITSHIFT, \
320 && SEND_BITAND, && SEND_BITOR, \
321 && SEND_BITXOR, \
322 \
323 && SEND_AT, && SEND_AT_PUT, \
324 && SEND_SIZE, && SEND_VALUE, \
325 && SEND_VALUE_ARG, && SEND_IDENTITY_EQ, \
326 && SEND_CLASS, && SEND_NEW, \
327 && SEND_NEW_ARG, \
328 }; \
329 goto *labels[*ip];
330 #else
331 #define SWITCH(ip) \
332 start: \
333 switch (*ip)
334 #endif
335
336 #ifdef I_HAS_COMPUTED_GOTO
337 #define CASE(OP) OP:
338 #else
339 #define CASE(OP) case OP:
340 #endif
341
342 #ifdef I_HAS_COMPUTED_GOTO
343 #define NEXT() goto *labels[*pr_ip]
344 #else
345 #define NEXT() goto start
346 #endif
347
348 const st_uchar *pr_ip;
349 st_uint pr_sp;
350
351 void
352 st_processor_main (st_processor *pr)
353 {
354 if (setjmp (pr->main_loop))
355 goto out;
356
357 pr_ip = pr->bytecode;
358
359 SWITCH (pr_ip) {
360
361 CASE (PUSH_TEMP) {
362
363 ST_STACK_PUSH (pr, pr->temps[pr_ip[1]]);
364
365 pr_ip += 2;
366 NEXT ();
367 }
368
369 CASE (PUSH_INSTVAR) {
370
371 ST_STACK_PUSH (pr, ST_OBJECT_FIELDS (pr->receiver)[pr_ip[1]]);
372
373 pr_ip += 2;
374 NEXT ();
375 }
376
377 CASE (STORE_POP_INSTVAR) {
378
379 ST_OBJECT_FIELDS (pr->receiver)[pr_ip[1]] = ST_STACK_POP (pr);
380
381 pr_ip += 2;
382 NEXT ();
383 }
384
385 CASE (STORE_INSTVAR) {
386
387 ST_OBJECT_FIELDS (pr->receiver)[pr_ip[1]] = ST_STACK_PEEK (pr);
388
389 pr_ip += 2;
390 NEXT ();
391 }
392
393 CASE (STORE_POP_TEMP) {
394
395 pr->temps[pr_ip[1]] = ST_STACK_POP (pr);
396
397 pr_ip += 2;
398 NEXT ();
399 }
400
401 CASE (STORE_TEMP) {
402
403 pr->temps[pr_ip[1]] = ST_STACK_PEEK (pr);
404
405 pr_ip += 2;
406 NEXT ();
407 }
408
409 CASE (STORE_LITERAL_VAR) {
410
411 ST_ASSOCIATION_VALUE (pr->literals[pr_ip[1]]) = ST_STACK_PEEK (pr);
412
413 pr_ip += 2;
414 NEXT ();
415 }
416
417 CASE (STORE_POP_LITERAL_VAR) {
418
419 ST_ASSOCIATION_VALUE (pr->literals[pr_ip[1]]) = ST_STACK_POP (pr);
420
421 pr_ip += 2;
422 NEXT ();
423 }
424
425 CASE (PUSH_SELF) {
426
427 ST_STACK_PUSH (pr, pr->receiver);
428
429 pr_ip += 1;
430 NEXT ();
431 }
432
433 CASE (PUSH_TRUE) {
434
435 ST_STACK_PUSH (pr, st_true);
436
437 pr_ip += 1;
438 NEXT ();
439 }
440
441 CASE (PUSH_FALSE) {
442
443 ST_STACK_PUSH (pr, st_false);
444
445 pr_ip += 1;
446 NEXT ();
447 }
448
449 CASE (PUSH_NIL) {
450
451 ST_STACK_PUSH (pr, st_nil);
452
453 pr_ip += 1;
454 NEXT ();
455 }
456
457 CASE (PUSH_INTEGER) {
458
459 ST_STACK_PUSH (pr, st_smi_new ((signed char) pr_ip[1]));
460
461 pr_ip += 2;
462 NEXT ();
463 }
464
465 CASE (PUSH_ACTIVE_CONTEXT) {
466
467 ST_STACK_PUSH (pr, pr->context);
468
469 pr_ip += 1;
470 NEXT ();
471 }
472
473 CASE (PUSH_LITERAL_CONST) {
474
475 ST_STACK_PUSH (pr, pr->literals[pr_ip[1]]);
476
477 pr_ip += 2;
478 NEXT ();
479 }
480
481 CASE (PUSH_LITERAL_VAR) {
482
483 st_oop var;
484
485 var = ST_ASSOCIATION (pr->literals[pr_ip[1]])->value;
486
487 ST_STACK_PUSH (pr, var);
488
489 pr_ip += 2;
490 NEXT ();
491 }
492
493 CASE (JUMP_TRUE) {
494
495 if (ST_STACK_PEEK (pr) == st_true) {
496 (void) ST_STACK_POP (pr);
497 pr_ip += 3 + *((short *) (pr_ip + 1));
498 } else if (ST_LIKELY (ST_STACK_PEEK (pr) == st_false)) {
499 (void) ST_STACK_POP (pr);
500 pr_ip += 3;
501 } else {
502 pr_ip += 3;
503 SEND_SELECTOR (pr, st_selector_mustBeBoolean, 0);
504 }
505
506 NEXT ();
507 }
508
509 CASE (JUMP_FALSE) {
510
511 if (ST_STACK_PEEK (pr) == st_false) {
512 (void) ST_STACK_POP (pr);
513 pr_ip += 3 + *((short *) (pr_ip + 1));
514 } else if (ST_LIKELY (ST_STACK_PEEK (pr) == st_true)) {
515 (void) ST_STACK_POP (pr);
516 pr_ip += 3;
517 } else {
518 pr_ip += 3;
519 SEND_SELECTOR (pr, st_selector_mustBeBoolean, 0);
520 }
521
522 NEXT ();
523 }
524
525 CASE (JUMP) {
526
527 short offset = *((short *) (pr_ip + 1));
528
529 pr_ip += ((offset >= 0) ? 3 : 0) + offset;
530
531 NEXT ();
532 }
533
534 CASE (SEND_PLUS) {
535
536 st_oop a, b;
537
538 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
539 st_object_is_smi (pr->stack[pr_sp - 2]))) {
540 b = ST_STACK_POP (pr);
541 a = ST_STACK_POP (pr);
542 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) + st_smi_value (b)));
543 pr_ip++;
544 NEXT ();
545 }
546
547 pr->message_argcount = 1;
548 pr->message_selector = st_specials[ST_SPECIAL_PLUS];
549 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
550
551 SEND_TEMPLATE (pr);
552
553 NEXT ();
554 }
555
556 CASE (SEND_MINUS) {
557
558 st_oop a, b;
559
560 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
561 st_object_is_smi (pr->stack[pr_sp - 2]))) {
562 b = ST_STACK_POP (pr);
563 a = ST_STACK_POP (pr);
564 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) - st_smi_value (b)));
565 pr_ip++;
566 NEXT ();
567 }
568
569 pr->message_argcount = 1;
570 pr->message_selector = st_specials[ST_SPECIAL_MINUS];
571 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
572
573 SEND_TEMPLATE (pr);
574
575 NEXT ();
576 }
577
578 CASE (SEND_MUL) {
579
580 st_oop a, b;
581
582 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
583 st_object_is_smi (pr->stack[pr_sp - 2]))) {
584 b = ST_STACK_POP (pr);
585 a = ST_STACK_POP (pr);
586 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) * st_smi_value (b)));
587 pr_ip++;
588 NEXT ();
589 }
590
591 pr->message_argcount = 1;
592 pr->message_selector = st_specials[ST_SPECIAL_MUL];
593 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
594
595 SEND_TEMPLATE (pr);
596
597 NEXT ();
598
599 }
600
601 CASE (SEND_MOD) {
602
603 st_oop a, b;
604
605 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
606 st_object_is_smi (pr->stack[pr_sp - 2]))) {
607 b = ST_STACK_POP (pr);
608 a = ST_STACK_POP (pr);
609 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) % st_smi_value (b)));
610 pr_ip++;
611 NEXT ();
612 }
613
614 pr->message_argcount = 1;
615 pr->message_selector = st_specials[ST_SPECIAL_MOD];
616 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
617
618 SEND_TEMPLATE (pr);
619
620 NEXT ();
621
622 }
623
624 CASE (SEND_DIV) {
625
626 pr->message_argcount = 1;
627 pr->message_selector = st_specials[ST_SPECIAL_DIV];
628 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
629
630 SEND_TEMPLATE (pr);
631
632 NEXT ();
633 }
634
635 CASE (SEND_BITSHIFT) {
636
637 st_oop a, b;
638
639 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
640 st_object_is_smi (pr->stack[pr_sp - 2]))) {
641 b = ST_STACK_POP (pr);
642 a = ST_STACK_POP (pr);
643 if (st_smi_value (b) < 0) {
644 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) >> -st_smi_value (b)));
645 } else
646 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) << st_smi_value (b)));
647 pr_ip++;
648 NEXT ();
649 }
650
651 pr->message_argcount = 1;
652 pr->message_selector = st_specials[ST_SPECIAL_BITSHIFT];
653 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
654
655 SEND_TEMPLATE (pr);
656
657 NEXT ();
658 }
659
660 CASE (SEND_BITAND) {
661
662 st_oop a, b;
663
664 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
665 st_object_is_smi (pr->stack[pr_sp - 2]))) {
666 b = ST_STACK_POP (pr);
667 a = ST_STACK_POP (pr);
668 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) & st_smi_value (b)));
669 pr_ip++;
670 NEXT ();
671 }
672
673 pr->message_argcount = 1;
674 pr->message_selector = st_specials[ST_SPECIAL_BITAND];
675 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
676
677 SEND_TEMPLATE (pr);
678
679 NEXT ();
680 }
681
682 CASE (SEND_BITOR) {
683
684 st_oop a, b;
685
686 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
687 st_object_is_smi (pr->stack[pr_sp - 2]))) {
688 b = ST_STACK_POP (pr);
689 a = ST_STACK_POP (pr);
690 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) | st_smi_value (b)));
691 pr_ip++;
692 NEXT ();
693 }
694
695 pr->message_argcount = 1;
696 pr->message_selector = st_specials[ST_SPECIAL_BITOR];
697 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
698
699 SEND_TEMPLATE (pr);
700
701 NEXT ();
702 }
703
704 CASE (SEND_BITXOR) {
705
706 st_oop a, b;
707
708 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
709 st_object_is_smi (pr->stack[pr_sp - 2]))) {
710 b = ST_STACK_POP (pr);
711 a = ST_STACK_POP (pr);
712 ST_STACK_PUSH (pr, st_smi_new (st_smi_value (a) ^ st_smi_value (b)));
713 pr_ip++;
714 NEXT ();
715 }
716
717 pr->message_argcount = 1;
718 pr->message_selector = st_specials[ST_SPECIAL_BITXOR];
719 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
720
721 SEND_TEMPLATE (pr);
722
723 NEXT ();
724 }
725
726 CASE (SEND_LT) {
727
728 st_oop a, b;
729
730 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
731 st_object_is_smi (pr->stack[pr_sp - 2]))) {
732 b = ST_STACK_POP (pr);
733 a = ST_STACK_POP (pr);
734 ST_STACK_PUSH (pr, st_smi_value (a) < st_smi_value (b) ? st_true : st_false);
735 pr_ip++;
736 NEXT ();
737 }
738
739 pr->message_argcount = 1;
740 pr->message_selector = st_specials[ST_SPECIAL_LT];
741 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
742
743 SEND_TEMPLATE (pr);
744
745 NEXT ();
746 }
747
748 CASE (SEND_GT) {
749
750 st_oop a, b;
751
752 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
753 st_object_is_smi (pr->stack[pr_sp - 2]))) {
754 b = ST_STACK_POP (pr);
755 a = ST_STACK_POP (pr);
756 ST_STACK_PUSH (pr, st_smi_value (a) > st_smi_value (b) ? st_true : st_false);
757 pr_ip++;
758 NEXT ();
759 }
760
761 pr->message_argcount = 1;
762 pr->message_selector = st_specials[ST_SPECIAL_GT];
763 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
764
765 SEND_TEMPLATE (pr);
766
767 NEXT ();
768 }
769
770 CASE (SEND_LE) {
771
772 st_oop a, b;
773
774 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
775 st_object_is_smi (pr->stack[pr_sp - 2]))) {
776 b = ST_STACK_POP (pr);
777 a = ST_STACK_POP (pr);
778 ST_STACK_PUSH (pr, st_smi_value (a) <= st_smi_value (b) ? st_true : st_false);
779 pr_ip++;
780 NEXT ();
781 }
782
783 pr->message_argcount = 1;
784 pr->message_selector = st_specials[ST_SPECIAL_LE];
785 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
786
787 SEND_TEMPLATE (pr);
788
789 NEXT ();
790 }
791
792 CASE (SEND_GE) {
793
794 st_oop a, b;
795
796 if (ST_LIKELY (st_object_is_smi (pr->stack[pr_sp - 1]) &&
797 st_object_is_smi (pr->stack[pr_sp - 2]))) {
798 b = ST_STACK_POP (pr);
799 a = ST_STACK_POP (pr);
800 ST_STACK_PUSH (pr, st_smi_value (a) >= st_smi_value (b) ? st_true : st_false);
801 pr_ip++;
802 NEXT ();
803 }
804
805 pr->message_argcount = 1;
806 pr->message_selector = st_specials[ST_SPECIAL_GE];
807 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
808
809 SEND_TEMPLATE (pr);
810
811 NEXT ();
812 }
813
814 CASE (SEND_CLASS) {
815
816 pr->message_argcount = 0;
817 pr->message_selector = st_specials[ST_SPECIAL_CLASS];
818 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
819
820 SEND_TEMPLATE (pr);
821
822 NEXT ();
823 }
824
825 CASE (SEND_SIZE) {
826
827 pr->message_argcount = 0;
828 pr->message_selector = st_specials[ST_SPECIAL_SIZE];
829 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
830
831 SEND_TEMPLATE (pr);
832
833 NEXT ();
834 }
835
836 CASE (SEND_AT) {
837
838 pr->message_argcount = 1;
839 pr->message_selector = st_specials[ST_SPECIAL_AT];
840 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
841
842 SEND_TEMPLATE (pr);
843
844 NEXT ();
845 }
846
847 CASE (SEND_AT_PUT) {
848
849 pr->message_argcount = 2;
850 pr->message_selector = st_specials[ST_SPECIAL_ATPUT];
851 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
852
853 SEND_TEMPLATE (pr);
854
855 NEXT ();
856 }
857
858 CASE (SEND_EQ) {
859
860 pr->message_argcount = 1;
861 pr->message_selector = st_specials[ST_SPECIAL_EQ];
862 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
863
864 SEND_TEMPLATE (pr);
865
866 NEXT ();
867 }
868
869 CASE (SEND_NE) {
870
871 pr->message_argcount = 1;
872 pr->message_selector = st_specials[ST_SPECIAL_NE];
873 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
874
875 SEND_TEMPLATE (pr);
876
877 NEXT ();
878 }
879
880 CASE (SEND_IDENTITY_EQ) {
881
882 st_oop a, b;
883 a = ST_STACK_POP (pr);
884 b = ST_STACK_POP (pr);
885
886 ST_STACK_PUSH (pr, (a == b) ? st_true : st_false);
887
888 pr_ip += 1;
889 NEXT ();
890 }
891
892 CASE (SEND_VALUE) {
893
894 pr->message_argcount = 0;
895 pr->message_selector = st_specials[ST_SPECIAL_VALUE];
896 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
897
898 SEND_TEMPLATE (pr);
899
900 NEXT ();
901 }
902
903 CASE (SEND_VALUE_ARG) {
904
905 pr->message_argcount = 1;
906 pr->message_selector = st_specials[ST_SPECIAL_VALUE_ARG];
907 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
908
909 SEND_TEMPLATE (pr);
910
911 NEXT ();
912 }
913
914 CASE (SEND_NEW) {
915
916 pr->message_argcount = 0;
917 pr->message_selector = st_specials[ST_SPECIAL_NEW];
918 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
919
920 SEND_TEMPLATE (pr);
921
922 NEXT ();
923 }
924
925 CASE (SEND_NEW_ARG) {
926
927 pr->message_argcount = 1;
928 pr->message_selector = st_specials[ST_SPECIAL_NEW_ARG];
929 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
930
931 SEND_TEMPLATE (pr);
932
933 NEXT ();
934 }
935
936 CASE (SEND) {
937
938 st_uint primitive_index;
939 st_method_flags flags;
940
941 pr->message_argcount = pr_ip[1];
942 pr->message_selector = pr->literals[pr_ip[2]];
943 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
944
945 pr_ip += 3;
946
947 pr->new_method = st_processor_lookup_method (pr, st_object_class (pr->message_receiver));
948
949 flags = st_method_get_flags (pr->new_method);
950 if (flags == ST_METHOD_PRIMITIVE) {
951 primitive_index = st_method_get_primitive_index (pr->new_method);
952
953 EXECUTE_PRIMITIVE (pr, primitive_index);
954 if (ST_LIKELY (pr->success))
955 NEXT ();
956 }
957
958 ACTIVATE_METHOD (pr);
959 NEXT ();
960 }
961
962 CASE (SEND_SUPER) {
963
964 st_oop literal_index;
965 st_uint primitive_index;
966 st_method_flags flags;
967
968 pr->message_argcount = pr_ip[1];
969 pr->message_selector = pr->literals[pr_ip[2]];
970 pr->message_receiver = pr->stack[pr_sp - pr->message_argcount - 1];
971
972 pr_ip += 3;
973
974 literal_index = st_smi_value (st_arrayed_object_size (ST_METHOD_LITERALS (pr->method))) - 1;
975
976 pr->new_method = st_processor_lookup_method (pr, ST_BEHAVIOR_SUPERCLASS (pr->literals[literal_index]));
977
978 flags = st_method_get_flags (pr->new_method);
979 if (flags == ST_METHOD_PRIMITIVE) {
980 primitive_index = st_method_get_primitive_index (pr->new_method);
981
982 EXECUTE_PRIMITIVE (pr, primitive_index);
983 if (ST_LIKELY (pr->success))
984 NEXT ();
985 }
986
987 ACTIVATE_METHOD (pr);
988 NEXT ();
989 }
990
991 CASE (POP_STACK_TOP) {
992
993 (void) ST_STACK_POP (pr);
994
995 pr_ip += 1;
996 NEXT ();
997 }
998
999 CASE (DUPLICATE_STACK_TOP) {
1000
1001 ST_STACK_PUSH (pr, ST_STACK_PEEK (pr));
1002
1003 pr_ip += 1;
1004 NEXT ();
1005 }
1006
1007 CASE (BLOCK_COPY) {
1008
1009 st_oop block;
1010 st_oop home;
1011 st_uint argcount = pr_ip[1];
1012 st_uint initial_ip;
1013
1014 pr_ip += 2;
1015
1016 initial_ip = pr_ip - pr->bytecode + 3;
1017
1018 block = block_context_new (pr, initial_ip, argcount);
1019
1020 ST_STACK_PUSH (pr, block);
1021
1022 NEXT ();
1023 }
1024
1025 CASE (RETURN_STACK_TOP) {
1026
1027 st_oop sender;
1028 st_oop value;
1029
1030 value = ST_STACK_PEEK (pr);
1031
1032 if (ST_OBJECT_CLASS (pr->context) == st_block_context_class)
1033 sender = ST_CONTEXT_PART_SENDER (ST_BLOCK_CONTEXT_HOME (pr->context));
1034 else
1035 sender = ST_CONTEXT_PART_SENDER (pr->context);
1036
1037 st_assert (st_object_is_heap (sender));
1038
1039 if (sender == st_nil) {
1040 ST_STACK_PUSH (pr, pr->context);
1041 ST_STACK_PUSH (pr, value);
1042 SEND_SELECTOR (pr, st_selector_cannotReturn, 1);
1043 NEXT ();
1044 }
1045
1046 if (ST_OBJECT_CLASS (pr->context) == st_method_context_class)
1047 st_memory_recycle_context (pr->context);
1048
1049 ACTIVATE_CONTEXT (pr, sender);
1050 ST_STACK_PUSH (pr, value);
1051
1052 NEXT ();
1053 }
1054
1055 CASE (BLOCK_RETURN) {
1056
1057 st_oop caller;
1058 st_oop value;
1059
1060 caller = ST_BLOCK_CONTEXT_CALLER (pr->context);
1061 value = ST_STACK_PEEK (pr);
1062 ACTIVATE_CONTEXT (pr, caller);
1063
1064 /* push returned value onto caller's stack */
1065 ST_STACK_PUSH (pr, value);
1066 st_assert (pr->context == caller);
1067
1068 NEXT ();
1069 }
1070 }
1071
1072 out:
1073 st_processor_prologue (pr);
1074 }
1075
1076 void
1077 st_processor_clear_caches (st_processor *pr)
1078 {
1079 for (st_uint i = 0; i < ST_METHOD_CACHE_SIZE; i++) {
1080 pr->method_cache[i].class = st_nil;
1081 pr->method_cache[i].selector = st_nil;
1082 pr->method_cache[i].method = st_nil;
1083 }
1084 }
1085
1086 void
1087 st_processor_initialize (st_processor *pr)
1088 {
1089 st_oop context;
1090 st_oop method;
1091
1092 /* clear contents */
1093 memset (pr, 0, sizeof (st_processor));
1094 pr->context = st_nil;
1095 pr->receiver = st_nil;
1096 pr->method = st_nil;
1097
1098 pr_sp = 0;
1099 pr->stack = NULL;
1100
1101 st_processor_clear_caches (pr);
1102
1103 pr->message_argcount = 0;
1104 pr->message_receiver = st_smalltalk;
1105 pr->message_selector = st_selector_startupSystem;
1106
1107 pr->new_method = st_processor_lookup_method (pr, st_object_class (pr->message_receiver));
1108 st_assert (st_method_get_flags (pr->new_method) == ST_METHOD_NORMAL);
1109
1110 context = method_context_new (pr);
1111 st_processor_set_active_context (pr, context);
1112 }
1113
A Smalltalk implementation