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