gdb/dstread.c

   1 /* Read apollo DST symbol tables and convert to internal format, for GDB.
   2    Contributed by Troy Rollo, University of NSW ([email protected]).
   3    Copyright 1993 Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20 \f
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "breakpoint.h"
  25 #include "bfd.h"
  26 #include "symfile.h"
  27 #include "objfiles.h"
  28 #include "buildsym.h"
  29 #include "obstack.h"
  30
  31 #include "gdb_string.h"
  32
  33 #include "dst.h"
  34
  35 CORE_ADDR cur_src_start_addr, cur_src_end_addr;
  36 dst_sec blocks_info, lines_info, symbols_info;
  37
  38 /* Vector of line number information.  */
  39
  40 static struct linetable *line_vector;
  41
  42 /* Index of next entry to go in line_vector_index.  */
  43
  44 static int line_vector_index;
  45
  46 /* Last line number recorded in the line vector.  */
  47
  48 static int prev_line_number;
  49
  50 /* Number of elements allocated for line_vector currently.  */
  51
  52 static int line_vector_length;
  53
  54 static struct blockvector *
  55 make_blockvector PARAMS ((struct objfile *));
  56
  57 static int
  58 init_dst_sections PARAMS ((int));
  59
  60 static void
  61 read_dst_symtab PARAMS ((struct objfile *));
  62
  63 static void
  64 find_dst_sections PARAMS ((bfd *, sec_ptr, PTR));
  65
  66 static void
  67 dst_symfile_init PARAMS ((struct objfile *));
  68
  69 static void
  70 dst_new_init PARAMS ((struct objfile *));
  71
  72 static void
  73 dst_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
  74
  75 static void
  76 dst_symfile_finish PARAMS ((struct objfile *));
  77
  78 static void
  79 dst_end_symtab PARAMS ((struct objfile *));
  80
  81 static void
  82 complete_symtab PARAMS ((char *, CORE_ADDR, unsigned int));
  83
  84 static void
  85 dst_start_symtab PARAMS ((void));
  86
  87 static void
  88 dst_record_line PARAMS ((int, CORE_ADDR));
  89
  90 static struct blockvector *
  91 make_blockvector (objfile)
  92      struct objfile *objfile;
  93 {
  94   register struct pending_block *next, *next1;
  95   register struct blockvector *blockvector;
  96   register int i;
  97
  98   /* Count the length of the list of blocks.  */
  99
 100   for (next = pending_blocks, i = 0; next; next = next->next, i++);
 101
 102   blockvector = (struct blockvector *)
 103                   obstack_alloc (&objfile->symbol_obstack, sizeof (struct blockvector) + (i - 1) * sizeof (struct block *));
 104
 105   /* Copy the blocks into the blockvector.
 106      This is done in reverse order, which happens to put
 107      the blocks into the proper order (ascending starting address).
 108    */
 109
 110   BLOCKVECTOR_NBLOCKS (blockvector) = i;
 111   for (next = pending_blocks; next; next = next->next)
 112     BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
 113
 114   /* Now free the links of the list, and empty the list.  */
 115
 116   for (next = pending_blocks; next; next = next1)
 117     {
 118       next1 = next->next;
 119       free ((PTR)next);
 120     }
 121   pending_blocks = 0;
 122
 123   return blockvector;
 124 }
 125
 126 /* Manage the vector of line numbers.  */
 127 /* FIXME: Use record_line instead.  */
 128
 129 static void
 130 dst_record_line (line, pc)
 131      int line;
 132      CORE_ADDR pc;
 133 {
 134   struct linetable_entry *e;
 135   /* Make sure line vector is big enough.  */
 136
 137   if (line_vector_index + 2 >= line_vector_length)
 138     {
 139       line_vector_length *= 2;
 140       line_vector = (struct linetable *)
 141         xrealloc ((char *) line_vector, sizeof (struct linetable)
 142                   + (line_vector_length
 143                      * sizeof (struct linetable_entry)));
 144     }
 145
 146   e = line_vector->item + line_vector_index++;
 147   e->line = line; e->pc = pc;
 148 }
 149 \f
 150 /* Start a new symtab for a new source file.
 151    It indicates the start of data for one original source file.  */
 152 /* FIXME: use start_symtab, like coffread.c now does.  */
 153
 154 static void
 155 dst_start_symtab ()
 156 {
 157   /* Initialize the source file line number information for this file.  */
 158
 159   if (line_vector)              /* Unlikely, but maybe possible? */
 160     free ((PTR)line_vector);
 161   line_vector_index = 0;
 162   line_vector_length = 1000;
 163   prev_line_number = -2;        /* Force first line number to be explicit */
 164   line_vector = (struct linetable *)
 165     xmalloc (sizeof (struct linetable)
 166              + line_vector_length * sizeof (struct linetable_entry));
 167 }
 168
 169 /* Save the vital information from when starting to read a file,
 170    for use when closing off the current file.
 171    NAME is the file name the symbols came from, START_ADDR is the first
 172    text address for the file, and SIZE is the number of bytes of text.  */
 173
 174 static void
 175 complete_symtab (name, start_addr, size)
 176     char *name;
 177     CORE_ADDR start_addr;
 178     unsigned int size;
 179 {
 180   last_source_file = savestring (name, strlen (name));
 181   cur_src_start_addr = start_addr;
 182   cur_src_end_addr = start_addr + size;
 183
 184   if (current_objfile -> ei.entry_point >= cur_src_start_addr &&
 185       current_objfile -> ei.entry_point <  cur_src_end_addr)
 186     {
 187       current_objfile -> ei.entry_file_lowpc = cur_src_start_addr;
 188       current_objfile -> ei.entry_file_highpc = cur_src_end_addr;
 189     }
 190 }
 191
 192 /* Finish the symbol definitions for one main source file,
 193    close off all the lexical contexts for that file
 194    (creating struct block's for them), then make the
 195    struct symtab for that file and put it in the list of all such. */
 196 /* FIXME: Use end_symtab, like coffread.c now does.  */
 197
 198 static void
 199 dst_end_symtab (objfile)
 200      struct objfile *objfile;
 201 {
 202   register struct symtab *symtab;
 203   register struct blockvector *blockvector;
 204   register struct linetable *lv;
 205
 206   /* Create the blockvector that points to all the file's blocks.  */
 207
 208   blockvector = make_blockvector (objfile);
 209
 210   /* Now create the symtab object for this source file.  */
 211   symtab = allocate_symtab (last_source_file, objfile);
 212
 213   /* Fill in its components.  */
 214   symtab->blockvector = blockvector;
 215   symtab->free_code = free_linetable;
 216   symtab->free_ptr = 0;
 217   symtab->filename = last_source_file;
 218   symtab->dirname = NULL;
 219   lv = line_vector;
 220   lv->nitems = line_vector_index;
 221   symtab->linetable = (struct linetable *)
 222     xrealloc ((char *) lv, (sizeof (struct linetable)
 223                    + lv->nitems * sizeof (struct linetable_entry)));
 224
 225   free_named_symtabs (symtab->filename);
 226
 227   /* Reinitialize for beginning of new file. */
 228   line_vector = 0;
 229   line_vector_length = -1;
 230   last_source_file = NULL;
 231 }
 232 \f
 233 /* dst_symfile_init ()
 234    is the dst-specific initialization routine for reading symbols.
 235
 236    We will only be called if this is a DST or DST-like file.
 237    BFD handles figuring out the format of the file, and code in symtab.c
 238    uses BFD's determination to vector to us.
 239
 240    The ultimate result is a new symtab (or, FIXME, eventually a psymtab).  */
 241
 242 static void
 243 dst_symfile_init (objfile)
 244      struct objfile *objfile;
 245 {
 246   asection      *section;
 247   bfd *abfd = objfile->obfd;
 248
 249   init_entry_point_info (objfile);
 250
 251 }
 252
 253 /* This function is called for every section; it finds the outer limits
 254    of the line table (minimum and maximum file offset) so that the
 255    mainline code can read the whole thing for efficiency.  */
 256
 257 /* ARGSUSED */
 258 static void
 259 find_dst_sections (abfd, asect, vpinfo)
 260      bfd *abfd;
 261      sec_ptr asect;
 262      PTR vpinfo;
 263 {
 264   int size, count;
 265   long base;
 266   file_ptr offset, maxoff;
 267   dst_sec *section;
 268
 269 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
 270   size = asect->_raw_size;
 271   offset = asect->filepos;
 272   base = asect->vma;
 273 /* End of warning */
 274
 275   section = NULL;
 276   if (!strcmp(asect->name, ".blocks"))
 277     section = &blocks_info;
 278   else if (!strcmp(asect->name, ".lines"))
 279     section = &lines_info;
 280   else if (!strcmp(asect->name, ".symbols"))
 281     section = &symbols_info;
 282   if (!section)
 283     return;
 284   section->size = size;
 285   section->position = offset;
 286   section->base = base;
 287 }
 288
 289
 290 /* The BFD for this file -- only good while we're actively reading
 291    symbols into a psymtab or a symtab.  */
 292
 293 static bfd *symfile_bfd;
 294
 295 /* Read a symbol file, after initialization by dst_symfile_init.  */
 296 /* FIXME!  Addr and Mainline are not used yet -- this will not work for
 297    shared libraries or add_file!  */
 298
 299 /* ARGSUSED */
 300 static void
 301 dst_symfile_read (objfile, section_offsets, mainline)
 302      struct objfile *objfile;
 303      struct section_offsets *section_offsets;
 304      int mainline;
 305 {
 306   bfd *abfd = objfile->obfd;
 307   char *name = bfd_get_filename (abfd);
 308   int desc;
 309   register int val;
 310   int num_symbols;
 311   int symtab_offset;
 312   int stringtab_offset;
 313
 314   symfile_bfd = abfd;                   /* Kludge for swap routines */
 315
 316 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
 317    desc = fileno ((GDB_FILE *)(abfd->iostream));        /* File descriptor */
 318
 319   /* Read the line number table, all at once.  */
 320   bfd_map_over_sections (abfd, find_dst_sections, (PTR)NULL);
 321
 322   val = init_dst_sections (desc);
 323   if (val < 0)
 324     error ("\"%s\": error reading debugging symbol tables\n", name);
 325
 326   init_minimal_symbol_collection ();
 327   make_cleanup (discard_minimal_symbols, 0);
 328
 329   /* Now that the executable file is positioned at symbol table,
 330      process it and define symbols accordingly.  */
 331
 332   read_dst_symtab (objfile);
 333
 334   /* Sort symbols alphabetically within each block.  */
 335
 336   {
 337     struct symtab *s;
 338     for (s = objfile -> symtabs; s != NULL; s = s -> next)
 339       {
 340         sort_symtab_syms (s);
 341       }
 342   }
 343
 344   /* Install any minimal symbols that have been collected as the current
 345      minimal symbols for this objfile. */
 346
 347   install_minimal_symbols (objfile);
 348 }
 349
 350 static void
 351 dst_new_init (ignore)
 352      struct objfile *ignore;
 353 {
 354         /* Nothin' to do */
 355 }
 356
 357 /* Perform any local cleanups required when we are done with a particular
 358    objfile.  I.E, we are in the process of discarding all symbol information
 359    for an objfile, freeing up all memory held for it, and unlinking the
 360    objfile struct from the global list of known objfiles. */
 361
 362 static void
 363 dst_symfile_finish (objfile)
 364      struct objfile *objfile;
 365 {
 366     /* Nothing to do */
 367 }
 368
 369 \f
 370 /* Get the next line number from the DST. Returns 0 when we hit an
 371  * end directive or cannot continue for any other reason.
 372  *
 373  * Note that ordinary pc deltas are multiplied by two. Apparently
 374  * this is what was really intended.
 375  */
 376 static int
 377 get_dst_line(buffer, pc)
 378     signed char **buffer;
 379     long *pc;
 380 {
 381         static last_pc = 0;
 382         static long last_line = 0;
 383         static int last_file = 0;
 384         dst_ln_entry_ptr_t entry;
 385         int size;
 386         dst_src_loc_t *src_loc;
 387
 388         if (*pc != -1)
 389         {
 390                 last_pc = *pc;
 391                 *pc = -1;
 392         }
 393         entry = (dst_ln_entry_ptr_t) *buffer;
 394
 395         while (dst_ln_ln_delta(*entry) == dst_ln_escape_flag)
 396         {
 397                 switch(entry->esc.esc_code)
 398                 {
 399                 case dst_ln_pad:
 400                         size = 1;         /* pad byte */
 401                         break;
 402                 case dst_ln_file:
 403                         /* file escape.  Next 4 bytes are a dst_src_loc_t */
 404                         size = 5;
 405                         src_loc = (dst_src_loc_t *) (*buffer + 1);
 406                         last_line = src_loc->line_number;
 407                         last_file = src_loc->file_index;
 408                         break;
 409                 case dst_ln_dln1_dpc1:
 410                         /* 1 byte line delta, 1 byte pc delta */
 411                         last_line += (*buffer)[1];
 412                         last_pc += 2 * (unsigned char) (*buffer)[2];
 413                         dst_record_line(last_line, last_pc);
 414                         size = 3;
 415                         break;
 416                 case dst_ln_dln2_dpc2:
 417                         /* 2 bytes line delta, 2 bytes pc delta */
 418                         last_line += *(short *) (*buffer + 1);
 419                         last_pc += 2 * (*(short *) (*buffer + 3));
 420                         size = 5;
 421                         dst_record_line(last_line, last_pc);
 422                         break;
 423                 case dst_ln_ln4_pc4:
 424                         /* 4 bytes ABSOLUTE line number, 4 bytes ABSOLUTE pc */
 425                         last_line = *(unsigned long *) (*buffer + 1);
 426                         last_pc = *(unsigned long *) (*buffer + 5);
 427                         size = 9;
 428                         dst_record_line(last_line, last_pc);
 429                         break;
 430                 case dst_ln_dln1_dpc0:
 431                         /* 1 byte line delta, pc delta = 0 */
 432                         size = 2;
 433                         last_line+= (*buffer)[1];
 434                         break;
 435                  case dst_ln_ln_off_1:
 436                         /* statement escape, stmt # = 1 (2nd stmt on line) */
 437                         size = 1;
 438                         break;
 439                 case dst_ln_ln_off:
 440                         /* statement escape, stmt # = next byte */
 441                         size = 2;
 442                         break;
 443                 case dst_ln_entry:
 444                         /* entry escape, next byte is entry number */
 445                         size = 2;
 446                         break;
 447                 case dst_ln_exit:
 448                         /* exit escape */
 449                         size = 1;
 450                         break;
 451                 case dst_ln_stmt_end:
 452                         /* gap escape, 4 bytes pc delta */
 453                         size = 5;
 454                         /* last_pc += 2 * (*(long *) (*buffer + 1)); */
 455                         /* Apparently this isn't supposed to actually modify
 456                          * the pc value. Totally weird.
 457                          */
 458                         break;
 459                  case dst_ln_escape_11:
 460                  case dst_ln_escape_12:
 461                  case dst_ln_escape_13:
 462                         size = 1;
 463                         break;
 464                  case dst_ln_nxt_byte:
 465                         /* This shouldn't happen. If it does, we're SOL */
 466                         return 0;
 467                         break;
 468                  case dst_ln_end:
 469                         /* end escape, final entry follows */
 470                         return 0;
 471                 }
 472                 *buffer += (size < 0) ? -size : size;
 473                 entry = (dst_ln_entry_ptr_t) *buffer;
 474         }
 475         last_line += dst_ln_ln_delta(*entry);
 476         last_pc += entry->delta.pc_delta * 2;
 477         (*buffer)++;
 478         dst_record_line(last_line, last_pc);
 479         return 1;
 480 }
 481
 482 static  void
 483 enter_all_lines(buffer, address)
 484     char *buffer;
 485     long address;
 486 {
 487     if (buffer)
 488         while (get_dst_line(&buffer, &address));
 489 }
 490
 491 static int
 492 get_dst_entry(buffer, ret_entry)
 493     char *buffer;
 494     dst_rec_ptr_t *ret_entry;
 495 {
 496     int size;
 497     dst_rec_ptr_t entry;
 498     static int last_type;
 499     int ar_size;
 500     static unsigned lu3;
 501
 502     entry = (dst_rec_ptr_t) buffer;
 503     switch(entry->rec_type)
 504     {
 505     case dst_typ_pad:
 506         size = 0;
 507         break;
 508     case dst_typ_comp_unit:
 509         size = sizeof(DST_comp_unit(entry));
 510         break;
 511     case dst_typ_section_tab:
 512         size = sizeof(DST_section_tab(entry))
 513                 + ((int) DST_section_tab(entry).number_of_sections
 514                    - dst_dummy_array_size) * sizeof(long);
 515         break;
 516     case dst_typ_file_tab:
 517         size = sizeof(DST_file_tab(entry))
 518                 + ((int) DST_file_tab(entry).number_of_files
 519                    - dst_dummy_array_size) * sizeof(dst_file_desc_t);
 520         break;
 521     case dst_typ_block:
 522         size = sizeof(DST_block(entry))
 523                 + ((int) DST_block(entry).n_of_code_ranges
 524                    - dst_dummy_array_size) * sizeof(dst_code_range_t);
 525         break;
 526     case dst_typ_5:
 527         size = -1;
 528         break;
 529     case dst_typ_var:
 530         size = sizeof(DST_var(entry)) -
 531                 sizeof(dst_var_loc_long_t) * dst_dummy_array_size +
 532                 DST_var(entry).no_of_locs *
 533                 ( DST_var(entry).short_locs ?
 534                   sizeof(dst_var_loc_short_t):
 535                   sizeof(dst_var_loc_long_t));
 536         break;
 537     case dst_typ_pointer:
 538         size = sizeof(DST_pointer(entry));
 539         break;
 540     case dst_typ_array:
 541         size = sizeof(DST_array(entry));
 542         break;
 543     case dst_typ_subrange:
 544         size = sizeof(DST_subrange(entry));
 545         break;
 546     case dst_typ_set:
 547         size = sizeof(DST_set(entry));
 548         break;
 549     case dst_typ_implicit_enum:
 550         size = sizeof(DST_implicit_enum(entry))
 551                 + ((int) DST_implicit_enum(entry).nelems
 552                    - dst_dummy_array_size) * sizeof(dst_rel_offset_t);
 553         break;
 554     case dst_typ_explicit_enum:
 555         size = sizeof(DST_explicit_enum(entry))
 556                 + ((int) DST_explicit_enum(entry).nelems
 557                    - dst_dummy_array_size) * sizeof(dst_enum_elem_t);
 558         break;
 559     case dst_typ_short_rec:
 560         size = sizeof(DST_short_rec(entry))
 561                 + DST_short_rec(entry).nfields * sizeof(dst_short_field_t)
 562                 - dst_dummy_array_size * sizeof(dst_field_t);
 563         break;
 564     case dst_typ_short_union:
 565         size = sizeof(DST_short_union(entry))
 566                 + DST_short_union(entry).nfields * sizeof(dst_short_field_t)
 567                 - dst_dummy_array_size * sizeof(dst_field_t);
 568         break;
 569     case dst_typ_file:
 570         size = sizeof(DST_file(entry));
 571         break;
 572     case dst_typ_offset:
 573         size = sizeof(DST_offset(entry));
 574         break;
 575     case dst_typ_alias:
 576         size = sizeof(DST_alias(entry));
 577         break;
 578     case dst_typ_signature:
 579         size = sizeof(DST_signature(entry)) +
 580                 ((int) DST_signature(entry).nargs -
 581                  dst_dummy_array_size) * sizeof(dst_arg_t);
 582         break;
 583     case dst_typ_21:
 584         size = -1;
 585         break;
 586     case dst_typ_old_label:
 587         size = sizeof(DST_old_label(entry));
 588         break;
 589     case dst_typ_scope:
 590         size = sizeof(DST_scope(entry));
 591         break;
 592     case dst_typ_end_scope:
 593         size = 0;
 594         break;
 595     case dst_typ_25:
 596     case dst_typ_26:
 597         size = -1;
 598         break;
 599     case dst_typ_string_tab:
 600     case dst_typ_global_name_tab:
 601         size = sizeof(DST_string_tab(entry))
 602                 + DST_string_tab(entry).length
 603                 - dst_dummy_array_size;
 604         break;
 605     case dst_typ_forward:
 606         size = sizeof(DST_forward(entry));
 607         get_dst_entry((char *) entry + DST_forward(entry).rec_off, &entry);
 608         break;
 609     case dst_typ_aux_size:
 610         size = sizeof(DST_aux_size(entry));
 611         break;
 612     case dst_typ_aux_align:
 613         size = sizeof(DST_aux_align(entry));
 614         break;
 615     case dst_typ_aux_field_size:
 616         size = sizeof(DST_aux_field_size(entry));
 617         break;
 618     case dst_typ_aux_field_off:
 619         size = sizeof(DST_aux_field_off(entry));
 620         break;
 621     case dst_typ_aux_field_align:
 622         size = sizeof(DST_aux_field_align(entry));
 623         break;
 624     case dst_typ_aux_qual:
 625         size = sizeof(DST_aux_qual(entry));
 626         break;
 627     case dst_typ_aux_var_bound:
 628         size = sizeof(DST_aux_var_bound(entry));
 629         break;
 630     case dst_typ_extension:
 631         size = DST_extension(entry).rec_size;
 632         break;
 633     case dst_typ_string:
 634         size = sizeof(DST_string(entry));
 635         break;
 636     case dst_typ_old_entry:
 637         size = 48; /* Obsolete entry type */
 638         break;
 639     case dst_typ_const:
 640         size = sizeof(DST_const(entry))
 641                 + DST_const(entry).value.length
 642                 - sizeof(DST_const(entry).value.val);
 643         break;
 644     case dst_typ_reference:
 645         size = sizeof(DST_reference(entry));
 646         break;
 647     case dst_typ_old_record:
 648     case dst_typ_old_union:
 649     case dst_typ_record:
 650     case dst_typ_union:
 651         size = sizeof(DST_record(entry))
 652                 + ((int) DST_record(entry).nfields
 653                    - dst_dummy_array_size) * sizeof(dst_field_t);
 654         break;
 655     case dst_typ_aux_type_deriv:
 656         size = sizeof(DST_aux_type_deriv(entry));
 657         break;
 658     case dst_typ_locpool:
 659         size = sizeof(DST_locpool(entry))
 660                 + ((int) DST_locpool(entry).length -
 661                    dst_dummy_array_size);
 662         break;
 663     case dst_typ_variable:
 664         size = sizeof(DST_variable(entry));
 665         break;
 666     case dst_typ_label:
 667         size = sizeof(DST_label(entry));
 668         break;
 669     case dst_typ_entry:
 670         size = sizeof(DST_entry(entry));
 671         break;
 672     case dst_typ_aux_lifetime:
 673         size = sizeof(DST_aux_lifetime(entry));
 674         break;
 675     case dst_typ_aux_ptr_base:
 676         size = sizeof(DST_aux_ptr_base(entry));
 677         break;
 678     case dst_typ_aux_src_range:
 679         size = sizeof(DST_aux_src_range(entry));
 680         break;
 681     case dst_typ_aux_reg_val:
 682         size = sizeof(DST_aux_reg_val(entry));
 683         break;
 684     case dst_typ_aux_unit_names:
 685         size = sizeof(DST_aux_unit_names(entry))
 686                 + ((int) DST_aux_unit_names(entry).number_of_names
 687                    - dst_dummy_array_size) * sizeof(dst_rel_offset_t);
 688         break;
 689     case dst_typ_aux_sect_info:
 690         size = sizeof(DST_aux_sect_info(entry))
 691                 + ((int) DST_aux_sect_info(entry).number_of_refs
 692                    - dst_dummy_array_size) * sizeof(dst_sect_ref_t);
 693         break;
 694     default:
 695         size = -1;
 696         break;
 697     }
 698     if (size == -1)
 699     {
 700         fprintf_unfiltered(gdb_stderr, "Warning: unexpected DST entry type (%d) found\nLast valid entry was of type: %d\n",
 701                 (int) entry->rec_type,
 702                 last_type);
 703         fprintf_unfiltered(gdb_stderr, "Last unknown_3 value: %d\n", lu3);
 704         size = 0;
 705     }
 706     else
 707         last_type = entry->rec_type;
 708     if (size & 1) /* Align on a word boundary */
 709         size++;
 710    size += 2;
 711    *ret_entry = entry;
 712    return size;
 713 }
 714
 715 static  int next_dst_entry(buffer, entry, table)
 716     char **buffer;
 717     dst_rec_ptr_t *entry;
 718     dst_sec *table;
 719 {
 720     if (*buffer - table->buffer >= table->size)
 721     {
 722         *entry = NULL;
 723         return 0;
 724     }
 725     *buffer += get_dst_entry(*buffer, entry);
 726     return 1;
 727 }
 728
 729 #define NEXT_BLK(a, b) next_dst_entry(a, b, &blocks_info)
 730 #define NEXT_SYM(a, b) next_dst_entry(a, b, &symbols_info)
 731 #define DST_OFFSET(a, b) ((char *) (a) + (b))
 732
 733 static  dst_rec_ptr_t   section_table = NULL;
 734
 735 char *
 736 get_sec_ref(ref)
 737     dst_sect_ref_t *ref;
 738 {
 739         dst_sec *section = NULL;
 740         long offset;
 741
 742         if (!section_table || !ref->sect_index)
 743                 return NULL;
 744         offset = DST_section_tab(section_table).section_base[ref->sect_index-1]
 745                 + ref->sect_offset;
 746         if (offset >= blocks_info.base &&
 747             offset < blocks_info.base + blocks_info.size)
 748                 section = &blocks_info;
 749         else if (offset >= symbols_info.base &&
 750                  offset < symbols_info.base + symbols_info.size)
 751                 section = &symbols_info;
 752         else if (offset >= lines_info.base &&
 753                  offset < lines_info.base + lines_info.size)
 754                 section = &lines_info;
 755         if (!section)
 756                 return NULL;
 757         return section->buffer + (offset - section->base);
 758 }
 759
 760 CORE_ADDR
 761 dst_get_addr(int section, long offset)
 762 {
 763         if (!section_table || !section)
 764                 return 0;
 765         return DST_section_tab(section_table).section_base[section-1] + offset;
 766 }
 767
 768 CORE_ADDR
 769 dst_sym_addr(ref)
 770     dst_sect_ref_t *ref;
 771 {
 772         if (!section_table || !ref->sect_index)
 773                 return 0;
 774         return DST_section_tab(section_table).section_base[ref->sect_index-1]
 775                 + ref->sect_offset;
 776 }
 777
 778 static struct type *
 779 create_new_type(objfile)
 780     struct objfile *objfile;
 781 {
 782         struct type *type;
 783
 784         type = (struct type *)
 785                 obstack_alloc (&objfile->symbol_obstack, sizeof (struct type));
 786         memset(type, 0, sizeof(struct type));
 787         return type;
 788 }
 789
 790 static struct symbol *
 791 create_new_symbol(objfile, name)
 792     struct objfile *objfile;
 793     char *name;
 794 {
 795         struct symbol *sym = (struct symbol *)
 796                obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
 797         memset (sym, 0, sizeof (struct symbol));
 798         SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
 799                                           &objfile->symbol_obstack);
 800         SYMBOL_VALUE (sym) = 0;
 801         SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 802
 803         SYMBOL_CLASS (sym) = LOC_BLOCK;
 804         return sym;
 805 };
 806
 807 static struct type *
 808 decode_dst_type PARAMS ((struct objfile *, dst_rec_ptr_t));
 809
 810 static struct type *
 811 decode_type_desc(objfile, type_desc, base)
 812         struct objfile *objfile;
 813         dst_type_t *type_desc;
 814         dst_rec_ptr_t base;
 815 {
 816         struct type *type;
 817         dst_rec_ptr_t entry;
 818         if (type_desc->std_type.user_defined_type)
 819         {
 820                 entry = (dst_rec_ptr_t) DST_OFFSET(base,
 821                                         dst_user_type_offset(*type_desc));
 822                 type = decode_dst_type(objfile, entry);
 823         }
 824         else
 825         {
 826                 switch(type_desc->std_type.dtc)
 827                 {
 828                 case dst_int8_type:
 829                         type = builtin_type_signed_char;
 830                         break;
 831                 case dst_int16_type:
 832                         type = builtin_type_short;
 833                         break;
 834                 case dst_int32_type:
 835                         type = builtin_type_long;
 836                         break;
 837                 case dst_uint8_type:
 838                         type = builtin_type_unsigned_char;
 839                         break;
 840                 case dst_uint16_type:
 841                         type = builtin_type_unsigned_short;
 842                         break;
 843                 case dst_uint32_type:
 844                         type = builtin_type_unsigned_long;
 845                         break;
 846                 case dst_real32_type:
 847                         type = builtin_type_float;
 848                         break;
 849                 case dst_real64_type:
 850                         type = builtin_type_double;
 851                         break;
 852                 case dst_complex_type:
 853                         type = builtin_type_complex;
 854                         break;
 855                 case dst_dcomplex_type:
 856                         type = builtin_type_double_complex;
 857                         break;
 858                 case dst_bool8_type:
 859                         type = builtin_type_char;
 860                         break;
 861                 case dst_bool16_type:
 862                         type = builtin_type_short;
 863                         break;
 864                 case dst_bool32_type:
 865                         type = builtin_type_long;
 866                         break;
 867                 case dst_char_type:
 868                         type = builtin_type_char;
 869                         break;
 870                 /* The next few are more complex. I will take care
 871                  * of them properly at a later point.
 872                  */
 873                 case dst_string_type:
 874                         type = builtin_type_void;
 875                         break;
 876                 case dst_ptr_type:
 877                         type = builtin_type_void;
 878                         break;
 879                 case dst_set_type:
 880                         type = builtin_type_void;
 881                         break;
 882                 case dst_proc_type:
 883                         type = builtin_type_void;
 884                         break;
 885                 case dst_func_type:
 886                         type = builtin_type_void;
 887                         break;
 888                 /* Back tto some ordinary ones */
 889                 case dst_void_type:
 890                         type = builtin_type_void;
 891                         break;
 892                 case dst_uchar_type:
 893                         type = builtin_type_unsigned_char;
 894                         break;
 895                 default:
 896                         type = builtin_type_void;
 897                         break;
 898                 }
 899         }
 900         return type;
 901 }
 902
 903 struct  structure_list
 904     {
 905     struct structure_list *next;
 906     struct type *type;
 907     };
 908
 909 static struct structure_list *struct_list = NULL;
 910
 911 static struct type *
 912 find_dst_structure(name)
 913     char *name;
 914 {
 915         struct structure_list *element;
 916
 917         for (element = struct_list; element; element = element->next)
 918                 if (!strcmp(name, TYPE_NAME(element->type)))
 919                         return element->type;
 920         return NULL;
 921 }
 922
 923
 924 static struct type *
 925 decode_dst_structure(objfile, entry, code, version)
 926     struct objfile *objfile;
 927     dst_rec_ptr_t entry;
 928     int code;
 929     int version;
 930 {
 931         struct  type *type, *child_type;
 932         char    *struct_name;
 933         char    *name, *field_name;
 934         int     i;
 935         int     fieldoffset, fieldsize;
 936         dst_type_t type_desc;
 937         struct structure_list *element;
 938
 939         struct_name = DST_OFFSET(entry, DST_record(entry).noffset);
 940         name = concat( (code == TYPE_CODE_UNION)?"union ":"struct ",
 941                         struct_name, NULL);
 942         type = find_dst_structure(name);
 943         if (type)
 944         {
 945                 free((PTR) name);
 946                 return type;
 947         }
 948         type = create_new_type(objfile);
 949         TYPE_NAME(type) = obstack_copy0 (&objfile->symbol_obstack,
 950                                                 name, strlen(name));
 951         free((PTR) name);
 952         TYPE_CODE(type) = code;
 953         TYPE_LENGTH(type) = DST_record(entry).size;
 954         TYPE_NFIELDS(type) = DST_record(entry).nfields;
 955         TYPE_FIELDS(type) = (struct field *)
 956                obstack_alloc (&objfile->symbol_obstack, sizeof (struct field) *
 957                                         DST_record(entry).nfields);
 958         fieldoffset = fieldsize = 0;
 959         INIT_CPLUS_SPECIFIC(type);
 960         element = (struct structure_list *)
 961                                 xmalloc(sizeof(struct structure_list));
 962         element->type = type;
 963         element->next = struct_list;
 964         struct_list = element;
 965         for (i = 0; i < DST_record(entry).nfields; i++)
 966         {
 967                 switch (version)
 968                 {
 969                 case 2:
 970                         field_name = DST_OFFSET(entry,
 971                                         DST_record(entry).f.ofields[i].noffset);
 972                         fieldoffset = DST_record(entry).f.ofields[i].foffset*8 +
 973                                       DST_record(entry).f.ofields[i].bit_offset;
 974                         fieldsize = DST_record(entry).f.ofields[i].size;
 975                         type_desc = DST_record(entry).f.ofields[i].type_desc;
 976                         break;
 977                 case 1:
 978                         field_name = DST_OFFSET(entry,
 979                                         DST_record(entry).f.fields[i].noffset);
 980                         type_desc = DST_record(entry).f.fields[i].type_desc;
 981                         switch(DST_record(entry).f.fields[i].f.field_loc.format_tag)
 982                         {
 983                         case dst_field_byte:
 984                                 fieldoffset = DST_record(entry).f.
 985                                         fields[i].f.field_byte.offset * 8;
 986                                 fieldsize = -1;
 987                                 break;
 988                         case dst_field_bit:
 989                                 fieldoffset = DST_record(entry).f.
 990                                         fields[i].f.field_bit.byte_offset * 8 +
 991                                               DST_record(entry).f.
 992                                         fields[i].f.field_bit.bit_offset;
 993                                 fieldsize = DST_record(entry).f.
 994                                         fields[i].f.field_bit.nbits;
 995                                 break;
 996                         case dst_field_loc:
 997                                 fieldoffset += fieldsize;
 998                                 fieldsize = -1;
 999                                 break;
1000                         }
1001                         break;
1002                 case 0:
1003                         field_name = DST_OFFSET(entry,
1004                                         DST_record(entry).f.sfields[i].noffset);
1005                         fieldoffset = DST_record(entry).f.sfields[i].foffset;
1006                         type_desc = DST_record(entry).f.sfields[i].type_desc;
1007                         if (i < DST_record(entry).nfields - 1)
1008                                 fieldsize = DST_record(entry).f.sfields[i+1].foffset;
1009                         else
1010                                 fieldsize = DST_record(entry).size;
1011                         fieldsize -= fieldoffset;
1012                         fieldoffset *= 8;
1013                         fieldsize *= 8;
1014                 }
1015                 TYPE_FIELDS(type)[i].name =
1016                         obstack_copy0 (&objfile->symbol_obstack,
1017                                                 field_name, strlen(field_name));
1018                 TYPE_FIELDS(type)[i].type = decode_type_desc(objfile,
1019                                                 &type_desc,
1020                                                 entry);
1021                 if (fieldsize == -1)
1022                         fieldsize = TYPE_LENGTH(TYPE_FIELDS(type)[i].type) *
1023                                         8;
1024                 TYPE_FIELDS(type)[i].bitsize = fieldsize;
1025                 TYPE_FIELDS(type)[i].bitpos = fieldoffset;
1026         }
1027         return type;
1028 }
1029
1030 static struct type *
1031 decode_dst_type(objfile, entry)
1032     struct objfile *objfile;
1033     dst_rec_ptr_t entry;
1034 {
1035         struct type *child_type, *type, *range_type, *index_type;
1036
1037         switch(entry->rec_type)
1038         {
1039         case dst_typ_var:
1040                 return decode_type_desc(objfile,
1041                                         &DST_var(entry).type_desc,
1042                                         entry);
1043                 break;
1044         case dst_typ_variable:
1045                 return decode_type_desc(objfile,
1046                                         &DST_variable(entry).type_desc,
1047                                         entry);
1048                 break;
1049         case dst_typ_short_rec:
1050                 return decode_dst_structure(objfile, entry, TYPE_CODE_STRUCT,0);
1051         case dst_typ_short_union:
1052                 return decode_dst_structure(objfile, entry, TYPE_CODE_UNION, 0);
1053         case dst_typ_union:
1054                 return decode_dst_structure(objfile, entry, TYPE_CODE_UNION, 1);
1055         case dst_typ_record:
1056                 return decode_dst_structure(objfile, entry, TYPE_CODE_STRUCT,1);
1057         case dst_typ_old_union:
1058                 return decode_dst_structure(objfile, entry, TYPE_CODE_UNION, 2);
1059         case dst_typ_old_record:
1060                 return decode_dst_structure(objfile, entry, TYPE_CODE_STRUCT,2);
1061         case dst_typ_pointer:
1062                 return make_pointer_type(
1063                                 decode_type_desc(objfile,
1064                                         &DST_pointer(entry).type_desc,
1065                                         entry),
1066                                 NULL);
1067         case dst_typ_array:
1068                 child_type = decode_type_desc(objfile,
1069                                              &DST_pointer(entry).type_desc,
1070                                              entry);
1071                 index_type = lookup_fundamental_type(objfile,
1072                                                         FT_INTEGER);
1073                 range_type = create_range_type ((struct type *) NULL,
1074                                 index_type, DST_array(entry).lo_bound,
1075                                         DST_array(entry).hi_bound);
1076                 return create_array_type ((struct type *) NULL, child_type,
1077                                         range_type);
1078         case dst_typ_alias:
1079                 return decode_type_desc(objfile,
1080                                         &DST_alias(entry).type_desc,
1081                                         entry);
1082         default:
1083                 return builtin_type_int;
1084         }
1085 }
1086
1087 struct  symbol_list {
1088         struct symbol_list *next;
1089         struct symbol *symbol;
1090 };
1091
1092 static  struct  symbol_list *dst_global_symbols = NULL;
1093 static  int     total_globals = 0;
1094
1095 static void
1096 decode_dst_locstring(locstr, sym)
1097     char *locstr;
1098     struct symbol *sym;
1099 {
1100         dst_loc_entry_t *entry, *next_entry;
1101         CORE_ADDR       temp;
1102         int count = 0;
1103
1104         while(1)
1105         {
1106                 if (count++ == 100)
1107                 {
1108                         fprintf_unfiltered(gdb_stderr, "Error reading locstring\n");
1109                         break;
1110                 }
1111                 entry = (dst_loc_entry_t *) locstr;
1112                 next_entry = (dst_loc_entry_t *) (locstr + 1);
1113                 switch (entry->header.code)
1114                 {
1115                 case dst_lsc_end:       /* End of string */
1116                         return;
1117                 case dst_lsc_indirect:/* Indirect through previous. Arg == 6 */
1118                                         /* Or register ax x == arg */
1119                         if (entry->header.arg < 6)
1120                         {
1121                                 SYMBOL_CLASS(sym) = LOC_REGISTER;
1122                                 SYMBOL_VALUE(sym) = entry->header.arg + 8;
1123                         }
1124                         /* We predict indirects */
1125                         locstr++;
1126                         break;
1127                 case dst_lsc_dreg:
1128                         SYMBOL_CLASS(sym) = LOC_REGISTER;
1129                         SYMBOL_VALUE(sym) = entry->header.arg;
1130                         locstr++;
1131                         break;
1132                 case dst_lsc_section:/* Section (arg+1) */
1133                         SYMBOL_VALUE(sym) = dst_get_addr(entry->header.arg+1, 0);
1134                         locstr++;
1135                         break;
1136                 case dst_lsc_sec_byte: /* Section (next_byte+1) */
1137                         SYMBOL_VALUE(sym) = dst_get_addr(locstr[1]+1, 0);
1138                         locstr+=2;
1139                         break;
1140                 case dst_lsc_add:       /* Add (arg+1)*2 */
1141                 case dst_lsc_sub:       /* Subtract (arg+1)*2 */
1142                         temp = (entry->header.arg + 1) * 2;
1143                         locstr++;
1144                         if (*locstr == dst_multiply_256)
1145                         {
1146                                 temp <<= 8;
1147                                 locstr++;
1148                         }
1149                         switch(entry->header.code)
1150                         {
1151                         case dst_lsc_add:
1152                                 if (SYMBOL_CLASS(sym) == LOC_LOCAL)
1153                                         SYMBOL_CLASS(sym) = LOC_ARG;
1154                                 SYMBOL_VALUE(sym) += temp;
1155                                 break;
1156                         case dst_lsc_sub:
1157                                 SYMBOL_VALUE(sym) -= temp;
1158                                 break;
1159                         }
1160                         break;
1161                 case dst_lsc_add_byte:
1162                 case dst_lsc_sub_byte:
1163                         switch (entry->header.arg & 0x03)
1164                         {
1165                         case 1:
1166                                 temp = (unsigned char) locstr[1];
1167                                 locstr += 2;
1168                                 break;
1169                         case 2:
1170                                 temp = * (unsigned short *) (locstr + 1);
1171                                 locstr += 3;
1172                                 break;
1173                         case 3:
1174                                 temp = * (unsigned long *) (locstr + 1);
1175                                 locstr += 5;
1176                                 break;
1177                         }
1178                         if (*locstr == dst_multiply_256)
1179                         {
1180                                 temp <<= 8;
1181                                 locstr++;
1182                         }
1183                         switch(entry->header.code)
1184                         {
1185                         case dst_lsc_add_byte:
1186                                 if (SYMBOL_CLASS(sym) == LOC_LOCAL)
1187                                         SYMBOL_CLASS(sym) = LOC_ARG;
1188                                 SYMBOL_VALUE(sym) += temp;
1189                                 break;
1190                         case dst_lsc_sub_byte:
1191                                 SYMBOL_VALUE(sym) -= temp;
1192                                 break;
1193                         }
1194                         break;
1195                 case dst_lsc_sbreg:     /* Stack base register (frame pointer). Arg==0*/
1196                         if (next_entry->header.code != dst_lsc_indirect)
1197                         {
1198                                 SYMBOL_VALUE(sym) = 0;
1199                                 SYMBOL_CLASS(sym) = LOC_STATIC;
1200                                 return;
1201                         }
1202                         SYMBOL_VALUE(sym) = 0;
1203                         SYMBOL_CLASS(sym) = LOC_LOCAL;
1204                         locstr++;
1205                         break;
1206                 default:
1207                         SYMBOL_VALUE(sym) = 0;
1208                         SYMBOL_CLASS(sym) = LOC_STATIC;
1209                         return;
1210                 }
1211         }
1212 }
1213
1214 static struct symbol_list *
1215 process_dst_symbols(objfile, entry, name, nsyms_ret)
1216     struct objfile *objfile;
1217     dst_rec_ptr_t entry;
1218     char *name;
1219     int *nsyms_ret;
1220 {
1221         struct symbol_list *list = NULL, *element;
1222         struct symbol *sym;
1223         char *symname;
1224         int nsyms = 0;
1225         char *location;
1226         long line;
1227         dst_type_t symtype;
1228         struct type *type;
1229         dst_var_attr_t attr;
1230         dst_var_loc_t loc_type;
1231         unsigned loc_index;
1232         long    loc_value;
1233
1234         if (!entry)
1235         {
1236                 *nsyms_ret = 0;
1237                 return NULL;
1238         }
1239         location = (char *) entry;
1240         while (NEXT_SYM(&location, &entry) &&
1241                entry->rec_type != dst_typ_end_scope)
1242         {
1243                 if (entry->rec_type == dst_typ_var)
1244                 {
1245                         if (DST_var(entry).short_locs)
1246                         {
1247                                 loc_type = DST_var(entry).locs.shorts[0].loc_type;
1248                                 loc_index = DST_var(entry).locs.shorts[0].loc_index;
1249                                 loc_value = DST_var(entry).locs.shorts[0].location;
1250                         }
1251                         else
1252                         {
1253                                 loc_type = DST_var(entry).locs.longs[0].loc_type;
1254                                 loc_index = DST_var(entry).locs.longs[0].loc_index;
1255                                 loc_value = DST_var(entry).locs.longs[0].location;
1256                         }
1257                         if (loc_type == dst_var_loc_external)
1258                                 continue;
1259                         symname = DST_OFFSET(entry, DST_var(entry).noffset);
1260                         line = DST_var(entry).src_loc.line_number;
1261                         symtype = DST_var(entry).type_desc;
1262                         attr = DST_var(entry).attributes;
1263                 }
1264                 else if (entry->rec_type == dst_typ_variable)
1265                 {
1266                         symname = DST_OFFSET(entry,
1267                                                 DST_variable(entry).noffset);
1268                         line = DST_variable(entry).src_loc.line_number;
1269                         symtype = DST_variable(entry).type_desc;
1270                         attr = DST_variable(entry).attributes;
1271                 }
1272                 else
1273                 {
1274                         continue;
1275                 }
1276                 if (symname && name && !strcmp(symname, name))
1277                         /* It's the function return value */
1278                         continue;
1279                 sym = create_new_symbol(objfile, symname);
1280
1281                 if ((attr & (1<<dst_var_attr_global)) ||
1282                     (attr & (1<<dst_var_attr_static)))
1283                         SYMBOL_CLASS(sym) = LOC_STATIC;
1284                 else
1285                         SYMBOL_CLASS(sym) = LOC_LOCAL;
1286                 SYMBOL_LINE(sym) = line;
1287                 SYMBOL_TYPE(sym) = decode_type_desc(objfile, &symtype,
1288                                                 entry);
1289                 SYMBOL_VALUE(sym) = 0;
1290                 switch (entry->rec_type)
1291                 {
1292                 case dst_typ_var:
1293                         switch(loc_type)
1294                         {
1295                         case dst_var_loc_abs:
1296                                 SYMBOL_VALUE_ADDRESS(sym) = loc_value;
1297                                 break;
1298                         case dst_var_loc_sect_off:
1299                         case dst_var_loc_ind_sect_off: /* What is this? */
1300                                 SYMBOL_VALUE_ADDRESS(sym) = dst_get_addr(
1301                                                 loc_index,
1302                                                 loc_value);
1303                                 break;
1304                         case dst_var_loc_ind_reg_rel: /* What is this? */
1305                         case dst_var_loc_reg_rel:
1306                                 /* If it isn't fp relative, specify the
1307                                  * register it's relative to.
1308                                  */
1309                                 if (loc_index)
1310                                 {
1311                                         sym->aux_value.basereg = loc_index;
1312                                 }
1313                                 SYMBOL_VALUE(sym) = loc_value;
1314                                 if (loc_value > 0 &&
1315                                     SYMBOL_CLASS(sym) == LOC_BASEREG)
1316                                         SYMBOL_CLASS(sym) = LOC_BASEREG_ARG;
1317                                 break;
1318                         case dst_var_loc_reg:
1319                                 SYMBOL_VALUE(sym) = loc_index;
1320                                 SYMBOL_CLASS(sym) = LOC_REGISTER;
1321                                 break;
1322                         }
1323                         break;
1324                 case dst_typ_variable:
1325                         /* External variable..... don't try to interpret
1326                          * its nonexistant locstring.
1327                          */
1328                         if (DST_variable(entry).loffset == -1)
1329                                 continue;
1330                         decode_dst_locstring(DST_OFFSET(entry,
1331                                                 DST_variable(entry).loffset),
1332                                              sym);
1333                 }
1334                 element = (struct symbol_list *)
1335                                 xmalloc(sizeof(struct symbol_list));
1336
1337                 if (attr & (1<<dst_var_attr_global))
1338                 {
1339                         element->next = dst_global_symbols;
1340                         dst_global_symbols = element;
1341                         total_globals++;
1342                 }
1343                 else
1344                 {
1345                         element->next = list;
1346                         list = element;
1347                         nsyms++;
1348                 }
1349                 element->symbol = sym;
1350         }
1351         *nsyms_ret = nsyms;
1352         return list;
1353 }
1354
1355
1356 static struct symbol *
1357 process_dst_function(objfile, entry, name, address)
1358     struct objfile *objfile;
1359     dst_rec_ptr_t entry;
1360     char *name;
1361     CORE_ADDR address;
1362 {
1363         struct  symbol *sym;
1364         struct  type *type, *ftype;
1365         dst_rec_ptr_t sym_entry, typ_entry;
1366         char *location;
1367         struct symbol_list *element;
1368
1369         type = builtin_type_int;
1370         sym = create_new_symbol(objfile, name);
1371         SYMBOL_CLASS(sym) = LOC_BLOCK;
1372
1373         if (entry)
1374         {
1375                 location = (char *) entry;
1376                 do
1377                 {
1378                         NEXT_SYM(&location, &sym_entry);
1379                 } while (sym_entry && sym_entry->rec_type != dst_typ_signature);
1380
1381                 if (sym_entry)
1382                 {
1383                         SYMBOL_LINE(sym) =
1384                                 DST_signature(sym_entry).src_loc.line_number;
1385                         if (DST_signature(sym_entry).result)
1386                         {
1387                                 typ_entry = (dst_rec_ptr_t)
1388                                             DST_OFFSET(sym_entry,
1389                                             DST_signature(sym_entry).result);
1390                                 type = decode_dst_type(objfile, typ_entry);
1391                         }
1392                 }
1393         }
1394
1395         if (!type->function_type)
1396         {
1397                 ftype = create_new_type(objfile);
1398                 type->function_type = ftype;
1399                 ftype->target_type = type;
1400                 ftype->code = TYPE_CODE_FUNC;
1401         }
1402         SYMBOL_TYPE(sym) = type->function_type;
1403
1404         /* Now add ourselves to the global symbols list */
1405         element = (struct symbol_list *)
1406                         xmalloc(sizeof(struct symbol_list));
1407
1408         element->next = dst_global_symbols;
1409         dst_global_symbols = element;
1410         total_globals++;
1411         element->symbol = sym;
1412
1413         return sym;
1414 }
1415
1416 static struct block *
1417 process_dst_block(objfile, entry)
1418     struct objfile *objfile;
1419     dst_rec_ptr_t entry;
1420 {
1421         struct  block   *block;
1422         struct  symbol  *function = NULL;
1423         CORE_ADDR address;
1424         long    size;
1425         char    *name;
1426         dst_rec_ptr_t child_entry, symbol_entry;
1427         struct block *child_block;
1428         int     total_symbols = 0;
1429         struct pending_block *pblock;
1430         char    fake_name[20];
1431         static  long    fake_seq = 0;
1432         struct symbol_list *symlist, *nextsym;
1433         int     symnum;
1434
1435         if (DST_block(entry).noffset)
1436                 name = DST_OFFSET(entry, DST_block(entry).noffset);
1437         else
1438                 name = NULL;
1439         if (DST_block(entry).n_of_code_ranges)
1440         {
1441                 address = dst_sym_addr(
1442                                 &DST_block(entry).code_ranges[0].code_start);
1443                 size = DST_block(entry).code_ranges[0].code_size;
1444         }
1445         else
1446         {
1447                 address = -1;
1448                 size = 0;
1449         }
1450         symbol_entry = (dst_rec_ptr_t) get_sec_ref(&DST_block(entry).symbols_start);
1451         switch(DST_block(entry).block_type)
1452         {
1453         /* These are all really functions. Even the "program" type.
1454          * This is because the Apollo OS was written in Pascal, and
1455          * in Pascal, the main procedure is described as the Program.
1456          * Cute, huh?
1457          */
1458         case dst_block_procedure:
1459         case dst_block_function:
1460         case dst_block_subroutine:
1461         case dst_block_program:
1462                 prim_record_minimal_symbol(name, address, mst_text, objfile);
1463                 function = process_dst_function(
1464                         objfile,
1465                         symbol_entry,
1466                         name,
1467                         address);
1468                 enter_all_lines(get_sec_ref(&DST_block(entry).code_ranges[0].lines_start), address);
1469                 break;
1470         case dst_block_block_data:
1471                 break;
1472
1473         default:
1474                 /* GDB has to call it something, and the module name
1475                  * won't cut it
1476                  */
1477                 sprintf(fake_name, "block_%08lx", fake_seq++);
1478                 function = process_dst_function(
1479                         objfile, NULL, fake_name, address);
1480                 break;
1481         }
1482         symlist = process_dst_symbols(objfile, symbol_entry,
1483                                         name, &total_symbols);
1484         block = (struct block *)
1485             obstack_alloc (&objfile->symbol_obstack,
1486                                 sizeof (struct block) +
1487                                 (total_symbols - 1) * sizeof (struct symbol *));
1488
1489         symnum = 0;
1490         while (symlist)
1491         {
1492                 nextsym = symlist->next;
1493
1494                 block->sym[symnum] = symlist->symbol;
1495
1496                 free((PTR) symlist);
1497                 symlist = nextsym;
1498                 symnum++;
1499         }
1500         BLOCK_NSYMS (block) = total_symbols;
1501         BLOCK_START (block) = address;
1502         BLOCK_END (block) = address + size;
1503         BLOCK_SUPERBLOCK (block) = 0;
1504         if (function)
1505         {
1506                 SYMBOL_BLOCK_VALUE (function) = block;
1507                 BLOCK_FUNCTION (block) = function;
1508         }
1509         else
1510                 BLOCK_FUNCTION (block) = 0;
1511
1512         pblock = (struct pending_block *)
1513                         xmalloc (sizeof (struct pending_block));
1514         pblock->block = block;
1515         pblock->next = pending_blocks;
1516         pending_blocks = pblock;
1517         if (DST_block(entry).child_block_off)
1518         {
1519                 child_entry = (dst_rec_ptr_t) DST_OFFSET(entry,
1520                                         DST_block(entry).child_block_off);
1521                 while (child_entry)
1522                 {
1523                         child_block = process_dst_block(objfile, child_entry);
1524                         if (child_block)
1525                         {
1526                                 if (BLOCK_START(child_block) <
1527                                      BLOCK_START(block) ||
1528                                     BLOCK_START(block) == -1)
1529                                         BLOCK_START(block) =
1530                                              BLOCK_START(child_block);
1531                                 if (BLOCK_END(child_block) >
1532                                      BLOCK_END(block) ||
1533                                     BLOCK_END(block) == -1)
1534                                         BLOCK_END(block) =
1535                                              BLOCK_END(child_block);
1536                                 BLOCK_SUPERBLOCK (child_block) = block;
1537                         }
1538                         if (DST_block(child_entry).sibling_block_off)
1539                                 child_entry = (dst_rec_ptr_t) DST_OFFSET(
1540                                         child_entry,
1541                                         DST_block(child_entry).sibling_block_off);
1542                         else
1543                                 child_entry = NULL;
1544                 }
1545         }
1546         return block;
1547 }
1548
1549
1550 static void
1551 read_dst_symtab (objfile)
1552      struct objfile *objfile;
1553 {
1554         char    *buffer;
1555         dst_rec_ptr_t entry, file_table, root_block;
1556         char    *source_file;
1557         struct  block *block, *global_block;
1558         struct  pending_block *pblock;
1559         int     symnum;
1560         struct symbol_list *nextsym;
1561         int     module_num = 0;
1562         struct  structure_list *element;
1563
1564         current_objfile = objfile;
1565         buffer = blocks_info.buffer;
1566         while (NEXT_BLK(&buffer, &entry))
1567         {
1568                 if (entry->rec_type == dst_typ_comp_unit)
1569                 {
1570                         file_table = (dst_rec_ptr_t) DST_OFFSET(entry,
1571                                         DST_comp_unit(entry).file_table);
1572                         section_table = (dst_rec_ptr_t) DST_OFFSET(entry,
1573                                         DST_comp_unit(entry).section_table);
1574                         root_block = (dst_rec_ptr_t) DST_OFFSET(entry,
1575                                         DST_comp_unit(entry).root_block_offset);
1576                         source_file = DST_OFFSET(file_table,
1577                                         DST_file_tab(file_table).files[0].noffset);
1578                         /* Point buffer to the start of the next comp_unit */
1579                         buffer = DST_OFFSET(entry,
1580                                         DST_comp_unit(entry).data_size);
1581                         dst_start_symtab();
1582
1583                         pblock = (struct pending_block *)
1584                                 xmalloc (sizeof (struct pending_block));
1585                         pblock->next = NULL;
1586                         pending_blocks = pblock;
1587
1588                         block = process_dst_block(objfile, root_block);
1589
1590                         global_block = (struct block *)
1591                                     obstack_alloc (&objfile->symbol_obstack,
1592                                         sizeof (struct block) +
1593                                         (total_globals - 1) *
1594                                         sizeof (struct symbol *));
1595                         BLOCK_NSYMS(global_block) = total_globals;
1596                         for (symnum = 0; symnum < total_globals; symnum++)
1597                         {
1598                                 nextsym = dst_global_symbols->next;
1599
1600                                 global_block->sym[symnum] =
1601                                                 dst_global_symbols->symbol;
1602
1603                                 free((PTR) dst_global_symbols);
1604                                 dst_global_symbols = nextsym;
1605                         }
1606                         dst_global_symbols = NULL;
1607                         total_globals = 0;
1608                         BLOCK_FUNCTION(global_block) = 0;
1609                         BLOCK_START(global_block) = BLOCK_START(block);
1610                         BLOCK_END(global_block) = BLOCK_END(block);
1611                         BLOCK_SUPERBLOCK(global_block) = 0;
1612                         BLOCK_SUPERBLOCK(block) = global_block;
1613                         pblock->block = global_block;
1614
1615                         complete_symtab(source_file,
1616                                         BLOCK_START(block),
1617                                         BLOCK_END(block) - BLOCK_START(block));
1618                         module_num++;
1619                         dst_end_symtab(objfile);
1620                 }
1621         }
1622         if (module_num)
1623                 prim_record_minimal_symbol("<end_of_program>",
1624                                 BLOCK_END(block), mst_text, objfile);
1625         /* One more faked symbol to make sure nothing can ever run off the
1626          * end of the symbol table. This one represents the end of the
1627          * text space. It used to be (CORE_ADDR) -1 (effectively the highest
1628          * int possible), but some parts of gdb treated it as a signed
1629          * number and failed comparisons. We could equally use 7fffffff,
1630          * but no functions are ever mapped to an address higher than
1631          * 40000000
1632          */
1633         prim_record_minimal_symbol("<end_of_text>",
1634                                 (CORE_ADDR) 0x40000000,
1635                                 mst_text, objfile);
1636         while (struct_list)
1637         {
1638                 element = struct_list;
1639                 struct_list = element->next;
1640                 free((PTR) element);
1641         }
1642 }
1643
1644 \f
1645 /* Support for line number handling */
1646 static char *linetab = NULL;
1647 static long linetab_offset;
1648 static unsigned long linetab_size;
1649
1650 /* Read in all the line numbers for fast lookups later.  Leave them in
1651    external (unswapped) format in memory; we'll swap them as we enter
1652    them into GDB's data structures.  */
1653 static int
1654 init_one_section(chan, secinfo)
1655     int chan;
1656     dst_sec *secinfo;
1657 {
1658   if (secinfo->size == 0
1659       || lseek(chan, secinfo->position, 0) == -1
1660       || (secinfo->buffer = xmalloc(secinfo->size)) == NULL
1661       || myread(chan, secinfo->buffer, secinfo->size) == -1)
1662         return 0;
1663   else
1664         return 1;
1665 }
1666
1667 static int
1668 init_dst_sections (chan)
1669     int chan;
1670 {
1671
1672   if (!init_one_section(chan, &blocks_info) ||
1673       !init_one_section(chan, &lines_info) ||
1674       !init_one_section(chan, &symbols_info))
1675     return -1;
1676   else
1677     return 0;
1678 }
1679
1680 /* Fake up support for relocating symbol addresses.  FIXME.  */
1681
1682 struct section_offsets dst_symfile_faker = {0};
1683
1684 struct section_offsets *
1685 dst_symfile_offsets (objfile, addr)
1686      struct objfile *objfile;
1687      CORE_ADDR addr;
1688 {
1689   objfile->num_sections = 1;
1690   return &dst_symfile_faker;
1691 }
1692
1693 /* Register our ability to parse symbols for DST BFD files */
1694
1695 static struct sym_fns dst_sym_fns =
1696 {
1697   /* FIXME: Can this be integrated with coffread.c?  If not, should it be
1698      a separate flavour like ecoff?  */
1699   (enum bfd_flavour)-2,
1700
1701   dst_new_init,         /* sym_new_init: init anything gbl to entire symtab */
1702   dst_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
1703   dst_symfile_read,     /* sym_read: read a symbol file into symtab */
1704   dst_symfile_finish,   /* sym_finish: finished with file, cleanup */
1705   dst_symfile_offsets, /* sym_offsets:  xlate external to internal form */
1706   NULL                  /* next: pointer to next struct sym_fns */
1707 };
1708
1709 void
1710 _initialize_dstread ()
1711 {
1712   add_symtab_fns(&dst_sym_fns);
1713 }