![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bc-emit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to bc-emit.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Output bytecodes for GNU C-compiler.
2: Copyright (C) 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: #include "config.h"
22: #include "gvarargs.h"
23: #include "machmode.h"
24: #include "rtl.h"
25: #include "real.h"
26: #include "obstack.h"
27: #include "bytecode.h"
28: #ifdef __GNUC__
29: #include "bytetypes.h"
30: #endif
31: #include "bc-emit.h"
32: #include "bc-opcode.h"
33: #include "bc-typecd.h"
34: #include "bi-run.h"
35:
36: #include <stdio.h>
37:
38: extern char *xmalloc (), *xrealloc ();
39: extern void free ();
40:
41: extern struct obstack *rtl_obstack;
42:
43: /* Indexed by mode class, gives the narrowest mode for each class. */
44:
45: enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS];
46:
47: /* Commonly used modes. */
48: /* Mode whose width is BITS_PER_UNIT */
49: enum machine_mode byte_mode;
50:
51: /* Mode whose width is BITS_PER_WORD */
52: enum machine_mode word_mode;
53:
54: /* Vector indexed by opcode giving info about the args for each opcode. */
55: static struct arityvec arityvec[] = {
56: #include "bc-arity.h"
57: };
58:
59: /* How to print a symbol name for the assembler. */
60: static void
61: prsym (file, s)
62: FILE *file;
63: char *s;
64: {
65: if (*s == '*')
66: fprintf (file, "%s", s + 1);
67: else
68:
69: #ifdef NAMES_HAVE_UNDERSCORES
70: fprintf (file, "_%s", s);
71: #else
72: fprintf (file, "%s", s);
73: #endif
74:
75: }
76:
77: /* Maintain a bucket hash table for symbol names. */
78:
79: #define HASH_BITS 32
80: #define HASH_SIZE 509
81:
82: static struct bc_sym *hashtab[HASH_SIZE];
83:
84: static unsigned int
85: hash (name)
86: char *name;
87: {
88: unsigned int hash = 0;
89:
90: while (*name)
91: {
92: hash = hash << 3 | hash >> HASH_BITS - 3;
93: hash += *name++;
94: }
95:
96: return hash % HASH_SIZE;
97: }
98:
99:
100: /* Look up the named symbol, creating it if it doesn't exist. */
101: struct bc_sym *
102: sym_lookup (name)
103: char *name;
104: {
105: int i;
106: struct bc_sym *s;
107:
108: i = hash (name);
109: for (s = hashtab[i]; s; s = s->next)
110: if (!strcmp (s->name, name))
111: return s;
112:
113: s = (struct bc_sym *) xmalloc (sizeof (struct bc_sym));
114: s->name = xmalloc (strlen (name) + 1);
115: strcpy (s->name, name);
116: s->defined = s->global = s->common = 0;
117: s->val = 0;
118: s->next = hashtab[i];
119: hashtab[i] = s;
120: return s;
121: }
122:
123:
124: /* Write out .globl and common symbols to the named file. */
125: static void
126: bc_sym_write (file)
127: FILE *file;
128: {
129: int i;
130: struct bc_sym *s;
131:
132: for (i = 0; i < HASH_SIZE; ++i)
133: for (s = hashtab[i]; s; s = s->next)
134: {
135: if (s->global)
136: {
137: fprintf (file, "\n\t.globl ");
138: prsym (file, s->name);
139: putc ('\n', file);
140: if (s->common)
141: {
142: fprintf (file, "\n\t.comm ");
143: prsym (file, s->name);
144: fprintf (file, ", %d\n", s->val);
145: }
146: }
147: else if (s->common)
148: {
149: fprintf (file, "\n\t.lcomm ");
150: prsym (file, s->name);
151: fprintf (file, ", %d\n", s->val);
152: }
153: }
154: }
155:
156:
157:
158:
159: /* Create and initialize a new segment. */
160: static struct bc_seg *
161: seg_create ()
162: {
163: struct bc_seg *result;
164:
165: result = (struct bc_seg *) xmalloc (sizeof (struct bc_seg));
166: result->alloc = 256;
167: result->data = xmalloc (result->alloc);
168: result->size = 0;
169: result->syms = 0;
170: result->relocs = 0;
171: return result;
172: }
173:
174:
175: /* Advance the segment index to the next alignment boundary. */
176: static void
177: seg_align (seg, log)
178: struct bc_seg *seg;
179: int log;
180: {
181: unsigned int oldsize = seg->size;
182:
183: seg->size = seg->size + (1 << log) - 1 & ~((1 << log) - 1);
184: if (seg->size > seg->alloc)
185: {
186: while (seg->size > seg->alloc)
187: seg->alloc *= 2;
188: seg->data = xrealloc (seg->data, seg->alloc);
189: }
190: bzero (seg->data + oldsize, seg->size - oldsize);
191: }
192:
193:
194: /* Append the given data to the given segment. */
195: static void
196: seg_data (seg, data, size)
197: struct bc_seg *seg;
198: char *data;
199: unsigned int size;
200: {
201: if (seg->size + size > seg->alloc)
202: {
203: while (seg->size + size > seg->alloc)
204: seg->alloc *= 2;
205: seg->data = xrealloc (seg->data, seg->alloc);
206: }
207:
208: bcopy (data, seg->data + seg->size, size);
209: seg->size += size;
210: }
211:
212:
213: /* Append a zero-filled skip to the given segment. */
214: static void
215: seg_skip (seg, size)
216: struct bc_seg *seg;
217: unsigned int size;
218: {
219: if (seg->size + size > seg->alloc)
220: {
221: while (seg->size + size > seg->alloc)
222: seg->alloc *= 2;
223: seg->data = xrealloc (seg->data, seg->alloc);
224: }
225:
226: memset (seg->data + seg->size, 0, size);
227: seg->size += size;
228: }
229:
230:
231: /* Define the given name as the current offset in the given segment. It
232: is an error if the name is already defined. Return 0 or 1 indicating
233: failure or success respectively. */
234: static int
235: seg_defsym (seg, name)
236: struct bc_seg *seg;
237: char *name;
238: {
239: struct bc_sym *sym;
240: struct bc_segsym *segsym;
241:
242: sym = sym_lookup (name);
243: if (sym->defined)
244: return 0;
245:
246: sym->defined = 1;
247: sym->val = seg->size;
248: segsym = (struct bc_segsym *) xmalloc (sizeof (struct bc_segsym));
249: segsym->sym = sym;
250: segsym->next = seg->syms;
251: seg->syms = segsym;
252: return 1;
253: }
254:
255:
256: /* Generate in seg's data a reference to the given sym, adjusted by
257: the given offset. */
258: static void
259: seg_refsym (seg, name, offset)
260: struct bc_seg *seg;
261: char *name;
262: int offset;
263: {
264: struct bc_sym *sym;
265: struct bc_segreloc *segreloc;
266:
267: sym = sym_lookup (name);
268: segreloc = (struct bc_segreloc *) xmalloc (sizeof (struct bc_segreloc));
269: segreloc->offset = seg->size;
270: segreloc->sym = sym;
271: segreloc->next = seg->relocs;
272: seg->relocs = segreloc;
273: seg_data (seg, (char *) &offset, sizeof offset);
274: }
275:
276:
277: /* Concatenate the contents of given segments into the first argument. */
278: static void
279: seg_concat (result, seg)
280: struct bc_seg *result, *seg;
281: {
282: unsigned int fix;
283: struct bc_segsym *segsym;
284: struct bc_segreloc *segreloc;
285:
286: seg_align (result, MACHINE_SEG_ALIGN);
287: fix = result->size;
288: seg_data (result, seg->data, seg->size);
289: free (seg->data);
290:
291: /* Go through the symbols and relocs of SEG, adjusting their offsets
292: for their new location in RESULT. */
293: if (seg->syms)
294: {
295: segsym = seg->syms;
296: do
297: segsym->sym->val += fix;
298: while (segsym->next && (segsym = segsym->next));
299: segsym->next = result->syms;
300: result->syms = seg->syms;
301: }
302: if (seg->relocs)
303: {
304: segreloc = seg->relocs;
305: do
306: segreloc->offset += fix;
307: while (segreloc->next && (segreloc = segreloc->next));
308: segreloc->next = result->relocs;
309: result->relocs = seg->relocs;
310: }
311:
312: free ((char *) seg);
313: }
314:
315: /* Write a segment to a file. */
316: static void
317: bc_seg_write (seg, file)
318: struct bc_seg *seg;
319: FILE *file;
320: {
321: struct bc_segsym *segsym, *nsegsym, *psegsym;
322: struct bc_segreloc *segreloc, *nsegreloc, *psegreloc;
323: int i, offset, flag;
324:
325: /* Reverse the list of symbols. */
326: for (psegsym = 0, segsym = seg->syms; segsym; segsym = nsegsym)
327: {
328: nsegsym = segsym->next;
329: segsym->next = psegsym;
330: psegsym = segsym;
331: }
332: seg->syms = psegsym;
333:
334: /* Reverse the list of relocs. */
335: for (psegreloc = 0, segreloc = seg->relocs; segreloc; segreloc = nsegreloc)
336: {
337: nsegreloc = segreloc->next;
338: segreloc->next = psegreloc;
339: psegreloc = segreloc;
340: }
341: seg->relocs = psegreloc;
342:
343: /* Output each byte of the segment. */
344: for (i = 0, segsym = seg->syms, segreloc = seg->relocs; i < seg->size; ++i)
345: {
346: while (segsym && segsym->sym->val == i)
347: {
348: if (i % 8 != 0)
349: putc ('\n', file);
350:
351: BC_WRITE_SEGSYM (segsym, file);
352: segsym = segsym->next;
353: flag = 1;
354: }
355: if (segreloc && segreloc->offset == i)
356: {
357: if (i % 8 != 0)
358: putc ('\n', file);
359:
360: offset = *(int *) (seg->data + i);
361: i += sizeof (int) - 1;
362:
363: BC_WRITE_RELOC_ENTRY (segreloc, file, offset);
364: segreloc = segreloc->next;
365: flag = 1;
366: }
367: else
368: {
369: if (i % 8 == 0 || flag)
370: BC_START_BYTECODE_LINE (file);
371:
372: BC_WRITE_BYTECODE (i % 8 == 0 || flag ? ' ' : ',',
373: seg->data[i] & 0xFF,
374: file);
375: flag = 0;
376: if (i % 8 == 7)
377: putc ('\n', file);
378: }
379: }
380:
381: /* Paranoia check--we should have visited all syms and relocs during
382: the output pass. */
383:
384: if (segsym || segreloc)
385: abort ();
386: }
387:
388:
389:
390: /* Text and data segments of the object file in making. */
391: static struct bc_seg *bc_text_seg;
392: static struct bc_seg *bc_data_seg;
393:
394: /* Called before anything else in this module. */
395: void
396: bc_initialize ()
397: {
398: int min_class_size[(int) MAX_MODE_CLASS];
399: enum machine_mode mode;
400: int i;
401:
402: bc_init_mode_to_code_map ();
403:
404: bc_text_seg = seg_create ();
405: bc_data_seg = seg_create ();
406:
407: dconst0 = REAL_VALUE_ATOF ("0", DFmode);
408: dconst1 = REAL_VALUE_ATOF ("1", DFmode);
409: dconst2 = REAL_VALUE_ATOF ("2", DFmode);
410: dconstm1 = REAL_VALUE_ATOF ("-1", DFmode);
411:
412: /* Find the narrowest mode for each class and compute the word and byte
413: modes. */
414:
415: for (i = 0; i < (int) MAX_MODE_CLASS; i++)
416: min_class_size[i] = 1000;
417:
418: for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE;
419: mode = (enum machine_mode) ((int) mode + 1))
420: {
421: if (GET_MODE_SIZE (mode) < min_class_size[(int) GET_MODE_CLASS (mode)])
422: {
423: class_narrowest_mode[(int) GET_MODE_CLASS (mode)] = mode;
424: min_class_size[(int) GET_MODE_CLASS (mode)] = GET_MODE_SIZE (mode);
425: }
426: if (GET_MODE_CLASS (mode) == MODE_INT
427: && GET_MODE_BITSIZE (mode) == BITS_PER_UNIT)
428: byte_mode = mode;
429:
430: if (GET_MODE_CLASS (mode) == MODE_INT
431: && GET_MODE_BITSIZE (mode) == BITS_PER_WORD)
432: word_mode = mode;
433: }
434: }
435:
436:
437: /* External addresses referenced in a function. Rather than trying to
438: work relocatable address directly into bytecoded functions (which would
439: require us to provide hairy location info and possibly obey alignment
440: rules imposed by the architecture) we build an auxilary table of
441: pointer constants, and encode just offsets into this table into the
442: actual bytecode. */
443: static struct bc_seg *ptrconsts;
444:
445: /* Trampoline code for the function entry. */
446: struct bc_seg *trampoline;
447:
448: /* Actual byte code of the function. */
449: struct bc_seg *bytecode;
450:
451: /* List of labels defined in the function. */
452: struct bc_label *labels;
453:
454: /* List of label references in the function. */
455: struct bc_labelref *labelrefs;
456:
457:
458: /* Add symbol to pointer table. Return offset into table where
459: pointer was stored. The offset usually goes into the bytecode
460: stream as a constP literal. */
461: int
462: bc_define_pointer (p)
463: char *p;
464: {
465: int offset = ptrconsts->size;
466:
467: seg_refsym (ptrconsts, p, 0);
468: return offset;
469: }
470:
471:
472: /* Begin a bytecoded function. */
473: int
474: bc_begin_function (name)
475: char *name;
476: {
477: ptrconsts = seg_create ();
478: trampoline = seg_create ();
479: bytecode = seg_create ();
480: return seg_defsym (trampoline, name);
481: }
482:
483:
484: /* Force alignment in inline bytecode. */
485: void
486: bc_align_bytecode (align)
487: int align;
488: {
489: seg_align (bytecode, align);
490: }
491:
492:
493: /* Emit data inline into bytecode. */
494: void
495: bc_emit_bytecode_const (data, size)
496: char *data;
497: unsigned int size;
498: {
499: if (bytecode)
500: seg_data (bytecode, data, size);
501: }
502:
503:
504: /* Create a new "bytecode label", to have its value defined later.
505: Bytecode labels have nothing to do with the object file symbol table,
506: and are purely local to a given bytecoded function. */
507: struct bc_label *
508: bc_get_bytecode_label ()
509: {
510: struct bc_label *result;
511:
512: result = (struct bc_label *) xmalloc (sizeof (struct bc_label));
513: result->defined = 0;
514: result->next = labels;
515: result->uid = 0;
516: labels = result;
517: return result;
518: }
519:
520:
521: /* Define the given label with the current location counter. */
522: int
523: bc_emit_bytecode_labeldef (label)
524: struct bc_label *label;
525: {
526: extern int bc_new_uid ();
527:
528: if (!label || label->defined)
529: return 0;
530:
531: label->offset = bytecode->size;
532: label->defined = 1;
533: label->uid = bc_new_uid ();
534:
535: #ifdef DEBUG_PRINT_CODE
536: fprintf (stderr, "$%lx:\n", label);
537: #endif
538:
539: return 1;
540: }
541:
542:
543: /* Generate a location-relative reference to the given bytecode label.
544: It need not be defined yet; label references will be backpatched later. */
545: void
546: bc_emit_bytecode_labelref (label)
547: struct bc_label *label;
548: {
549: struct bc_labelref *labelref;
550: static int zero;
551:
552: labelref = (struct bc_labelref *) xmalloc (sizeof (struct bc_labelref));
553: labelref->label = label;
554: labelref->offset = bytecode->size;
555: labelref->next = labelrefs;
556: labelrefs = labelref;
557:
558: #ifdef DEBUG_PRINT_CODE
559: fprintf (stderr, " $%lx", label);
560: #endif
561:
562: seg_data (bytecode, (char *) &zero, sizeof zero);
563: }
564:
565:
566: /* Emit a reference to an external address; generate the reference in the
567: ptrconst area, and emit an offset in the bytecode. */
568: void
569: bc_emit_code_labelref (name, offset)
570: char *name;
571: int offset;
572: {
573: int ptroff;
574:
575: ptroff = ptrconsts->size / sizeof (char *);
576: seg_data (bytecode, (char *) &ptroff, sizeof ptroff);
577: seg_refsym (ptrconsts, name, offset);
578:
579: #ifdef DEBUG_PRINT_CODE
580: fprintf (stderr, " [external <%x> %s]", ptroff, name);
581: #endif
582: }
583:
584:
585: /* Backpatch label references in the byte code, and concatenate the bytecode
586: and pointer constant segments to the cumulative text for the object file.
587: Return a label name for the pointer constants region. */
588: char *
589: bc_end_function ()
590: {
591: int addr;
592: struct bc_label *label, *next;
593: struct bc_labelref *ref, *nextref;
594: char ptrconsts_label[20];
595: static int nlab;
596:
597: /* Backpatch bytecode label references. */
598: for (ref = labelrefs; ref; ref = ref->next)
599: if (ref->label->defined)
600: {
601: addr = ref->label->offset;
602: bcopy (&addr, bytecode->data + ref->offset, sizeof addr);
603: }
604:
605: /* Free the chains of labelrefs and labeldefs. */
606: for (ref = labelrefs; ref; ref = nextref)
607: {
608: nextref = ref->next;
609: free ((char *) ref);
610: }
611:
612: for (label = labels; label; label = next)
613: {
614: next = label->next;
615: free ((char *) label);
616: }
617:
618: seg_concat (trampoline, bytecode);
619: seg_align (trampoline, MACHINE_SEG_ALIGN);
620: sprintf (ptrconsts_label, "*LP%d", nlab++);
621: seg_defsym (trampoline, ptrconsts_label);
622: seg_concat (trampoline, ptrconsts);
623: seg_concat (bc_text_seg, trampoline);
624:
625: labels = 0;
626: labelrefs = 0;
627: trampoline = 0;
628: bytecode = 0;
629: ptrconsts = 0;
630:
631: return sym_lookup (ptrconsts_label)->name;
632: }
633:
634: /* Force alignment in const data. */
635: void
636: bc_align_const (align)
637: int align;
638: {
639: seg_align (bc_text_seg, align);
640: }
641:
642: /* Emit const data. */
643: void
644: bc_emit_const (data, size)
645: char *data;
646: unsigned int size;
647: {
648: seg_data (bc_text_seg, data, size);
649: }
650:
651: /* Emit a zero-filled constant skip. */
652: void
653: bc_emit_const_skip (size)
654: unsigned int size;
655: {
656: seg_skip (bc_text_seg, size);
657: }
658:
659: /* Emit a label definition in const data. */
660: int
661: bc_emit_const_labeldef (name)
662: char *name;
663: {
664: return seg_defsym (bc_text_seg, name);
665: }
666:
667: /* Emit a label reference in const data. */
668: void
669: bc_emit_const_labelref (name, offset)
670: char *name;
671: int offset;
672: {
673: seg_refsym (bc_text_seg, name, offset);
674: }
675:
676: /* Force alignment in data. */
677: void
678: bc_align_data (align)
679: int align;
680: {
681: seg_align (bc_data_seg, align);
682: }
683:
684: /* Emit data. */
685: void
686: bc_emit_data (data, size)
687: char *data;
688: unsigned int size;
689: {
690: seg_data (bc_data_seg, data, size);
691: }
692:
693: /* Emit a zero-filled data skip. */
694: void
695: bc_emit_data_skip (size)
696: unsigned int size;
697: {
698: seg_skip (bc_data_seg, size);
699: }
700:
701: /* Emit label definition in data. */
702: int
703: bc_emit_data_labeldef (name)
704: char *name;
705: {
706: return seg_defsym (bc_data_seg, name);
707: }
708:
709: /* Emit label reference in data. */
710: void
711: bc_emit_data_labelref (name, offset)
712: char *name;
713: int offset;
714: {
715: seg_refsym (bc_data_seg, name, offset);
716: }
717:
718: /* Emit a common block of the given name and size. Note that
719: when the .o file is actually written non-global "common"
720: blocks will have to be turned into space in the data section. */
721: int
722: bc_emit_common (name, size)
723: char *name;
724: unsigned int size;
725: {
726: struct bc_sym *sym;
727:
728: sym = sym_lookup (name);
729: if (sym->defined)
730: return 0;
731:
732: sym->defined = 1;
733: sym->common = 1;
734: sym->val = size;
735: return 1;
736: }
737:
738: /* Globalize the given label. */
739: void
740: bc_globalize_label (name)
741: char *name;
742: {
743: struct bc_sym *sym;
744:
745: sym = sym_lookup (name);
746: sym->global = 1;
747: }
748:
749: static enum { in_text, in_data } section = in_text;
750:
751: void
752: bc_text ()
753: {
754: section = in_text;
755: }
756:
757: void
758: bc_data ()
759: {
760: section = in_data;
761: }
762:
763: void
764: bc_align (align)
765: int align;
766: {
767: if (section == in_text)
768: bc_align_const (align);
769: else
770: bc_align_data (align);
771: }
772:
773: void
774: bc_emit (data, size)
775: char *data;
776: unsigned int size;
777: {
778: if (section == in_text)
779: bc_emit_const (data, size);
780: else
781: bc_emit_data (data, size);
782: }
783:
784: void
785: bc_emit_skip (size)
786: unsigned int size;
787: {
788: if (section == in_text)
789: bc_emit_const_skip (size);
790: else
791: bc_emit_data_skip (size);
792: }
793:
794: int
795: bc_emit_labeldef (name)
796: char *name;
797: {
798: if (section == in_text)
799: return bc_emit_const_labeldef (name);
800: else
801: return bc_emit_data_labeldef (name);
802: }
803:
804: void
805: bc_emit_labelref (name, offset)
806: char *name;
807: int offset;
808: {
809: if (section == in_text)
810: bc_emit_const_labelref (name, offset);
811: else
812: bc_emit_data_labelref (name, offset);
813: }
814:
815: void
816: bc_write_file (file)
817: FILE *file;
818: {
819: BC_WRITE_FILE (file);
820: }
821:
822:
823: /* Allocate a new bytecode rtx.
824: If you supply a null BC_LABEL, we generate one. */
825:
826: rtx
827: bc_gen_rtx (label, offset, bc_label)
828: char *label;
829: int offset;
830: struct bc_label *bc_label;
831: {
832: rtx r;
833:
834: if (bc_label == 0)
835: bc_label = (struct bc_label *) xmalloc (sizeof (struct bc_label));
836:
837: r = gen_rtx (CODE_LABEL, VOIDmode, label, bc_label);
838: bc_label->offset = offset;
839:
840: return r;
841: }
842:
843:
844: /* Print bytecode rtx */
845: void
846: bc_print_rtl (fp, r)
847: FILE *fp;
848: rtx r;
849: {
850: #if 0 /* This needs to get fixed to really work again. */
851: /* BC_WRITE_RTL has a definition
852: that doesn't even make sense for this use. */
853: BC_WRITE_RTL (r, fp);
854: #endif
855: }
856:
857:
858: /* Emit a bytecode, keeping a running tally of the stack depth. */
859: void
860: bc_emit_bytecode (bytecode)
861: enum bytecode_opcode bytecode;
862: {
863: char byte;
864: int npushes = arityvec[(int) bytecode].noutputs - arityvec[(int) bytecode].ninputs;
865: static int prev_lineno = -1;
866:
867: byte = bytecode;
868:
869: #ifdef BCDEBUG_PRINT_CODE
870: if (lineno != prev_lineno)
871: {
872: fprintf (stderr, "<line %d>\n", lineno);
873: prev_lineno = lineno;
874: }
875:
876: fputs (opcode_name[(unsigned int) bytecode], stderr);
877: #endif
878:
879: /* Due to errors we are often requested to output bytecodes that
880: will cause an interpreter stack undeflow when executed. Instead of
881: dumping core on such occasions, we omit the bytecode. Erroneous code
882: should not be executed, regardless. This makes life much easier, since
883: we don't have to deceive ourselves about the known stack depth. */
884:
885: bc_emit_bytecode_const (&byte, 1);
886:
887: if ((stack_depth -= arityvec[(int) bytecode].ninputs) >= 0)
888: {
889: if ((stack_depth += arityvec[(int) bytecode].noutputs) > max_stack_depth)
890: max_stack_depth = stack_depth;
891: }
892:
893: #ifdef VALIDATE_STACK_FOR_BC
894: VALIDATE_STACK_FOR_BC ();
895: #endif
896: }
897:
898:
899: #ifdef BCDEBUG_PRINT_CODE
900: #define PRLIT(TYPE, PTR) fprintf (stderr, " [%x]", *(TYPE *) PTR)
901: #else
902: #define PRLIT(X,Y)
903: #endif
904:
905: /* Emit a complete bytecode instruction, expecting the correct number
906: of literal values in the call. First argument is the instruction, the
907: remaining arguments are literals of size HOST_WIDE_INT or smaller. */
908: void
909: bc_emit_instruction (va_alist)
910: va_dcl
911: {
912: va_list arguments;
913: enum bytecode_opcode opcode;
914: int nliteral, instruction;
915:
916:
917: va_start (arguments);
918:
919: /* Emit instruction bytecode */
920: opcode = va_arg (arguments, enum bytecode_opcode);
921: bc_emit_bytecode (opcode);
922: instruction = (int) opcode;
923:
924: /* Loop literals and emit as bytecode constants */
925: for (nliteral = 0; nliteral < arityvec[instruction].nliterals; nliteral++)
926: {
927: HOST_WIDE_INT literal;
928:
929: switch (arityvec[instruction].literals[nliteral])
930: {
931: /* This conditional is a kludge, but it's necessary
932: because TYPE might be long long. */
933: #ifdef __GNUC__
934: /* Expand definitions into case statements */
935: #define DEFTYPECODE(CODE, NAME, MODE, TYPE) \
936: case CODE: \
937: { \
938: TYPE temp = va_arg (arguments, TYPE); \
939: bc_emit_bytecode_const ((void *) &temp, sizeof temp); \
940: PRLIT (TYPE, &temp); } \
941: break;
942:
943: #include "bc-typecd.def"
944:
945: #undef DEFTYPECODE
946: #endif /* __GNUC__ */
947:
948: default:
949: abort ();
950: }
951: }
952:
953: #ifdef BCDEBUG_PRINT_CODE
954: fputc ('\n', stderr);
955: #endif
956: }
957:
958: /* Emit the machine-code interface trampoline at the beginning of a byte
959: coded function. The argument is a label name of the interpreter
960: bytecode callinfo structure; the return value is a label name for
961: the beginning of the actual bytecode. */
962: char *
963: bc_emit_trampoline (callinfo)
964: char *callinfo;
965: {
966: char mylab[20];
967: static int n;
968:
969: sprintf (mylab, "*LB%d", n++);
970:
971: BC_EMIT_TRAMPOLINE (trampoline, callinfo);
972:
973: seg_defsym (bytecode, mylab);
974: return sym_lookup (mylab)->name;
975: }
976:
977:
978: /* Simple strdup */
979: char *
980: bc_xstrdup (str)
981: char *str;
982: {
983: char *tmp = xmalloc (strlen (str) + 1);
984:
985: strcpy (tmp, str);
986: return tmp;
987: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.