gcc/bc-emit.c

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