home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gcc-2.3.3-src.lha / GNU / src / amiga / gcc-2.3.3 / xcoffout.c < prev    next >
C/C++ Source or Header  |  1994-02-06  |  12KB  |  473 lines
  1. /* Output xcoff-format symbol table information from GNU compiler.
  2.    Copyright (C) 1992 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU CC.
  5.  
  6. GNU CC is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU CC is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU CC; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20.  
  21. /* Output xcoff-format symbol table data.  The main functionality is contained
  22.    in dbxout.c.  This file implements the sdbout-like parts of the xcoff
  23.    interface.  Many functions are very similar to their counterparts in
  24.    sdbout.c.  */
  25.  
  26. /* Include this first, because it may define MIN and MAX.  */
  27. #include <stdio.h>
  28.  
  29. #include "config.h"
  30. #include "tree.h"
  31. #include "rtl.h"
  32. #include "flags.h"
  33.  
  34. #ifdef XCOFF_DEBUGGING_INFO
  35.  
  36. /* This defines the C_* storage classes.  */
  37. #include <dbxstclass.h>
  38.  
  39. #include "xcoffout.h"
  40.  
  41. #if defined (USG) || defined (NO_STAB_H)
  42. #include "gstab.h"
  43. #else
  44. #include <stab.h>
  45.  
  46. /* This is a GNU extension we need to reference in this file.  */
  47. #ifndef N_CATCH
  48. #define N_CATCH 0x54
  49. #endif
  50. #endif
  51.  
  52. /* These are GNU extensions we need to reference in this file.  */
  53. #ifndef N_DSLINE
  54. #define N_DSLINE 0x46
  55. #endif
  56. #ifndef N_BSLINE
  57. #define N_BSLINE 0x48
  58. #endif
  59.  
  60. /* Line number of beginning of current function, minus one.
  61.    Negative means not in a function or not using xcoff.  */
  62.  
  63. int xcoff_begin_function_line = -1;
  64.  
  65. /* Name of the current include file.  */
  66.  
  67. char *xcoff_current_include_file;
  68.  
  69. /* Name of the current function file.  This is the file the `.bf' is
  70.    emitted from.  In case a line is emitted from a different file,
  71.    (by including that file of course), then the line number will be
  72.    absolute.  */
  73.  
  74. char *xcoff_current_function_file;
  75.  
  76. /* Names of bss and data sections.  These should be unique names for each
  77.    compilation unit.  */
  78.  
  79. char *xcoff_bss_section_name;
  80. char *xcoff_private_data_section_name;
  81. char *xcoff_read_only_section_name;
  82.  
  83. /* Macro definitions used below.  */
  84. /* Ensure we don't output a negative line number.  */
  85. #define MAKE_LINE_SAFE(LINE)  \
  86.   if (LINE <= xcoff_begin_function_line)    \
  87.     LINE = xcoff_begin_function_line + 1    \
  88.  
  89. #define ASM_OUTPUT_LFB(FILE,LINENUM) \
  90. {                        \
  91.   if (xcoff_begin_function_line == -1)        \
  92.     {                        \
  93.       xcoff_begin_function_line = (LINENUM) - 1;\
  94.       fprintf (FILE, "\t.bf\t%d\n", (LINENUM));    \
  95.     }                        \
  96.   xcoff_current_function_file            \
  97.     = (xcoff_current_include_file        \
  98.        ? xcoff_current_include_file : main_input_filename); \
  99. }
  100.  
  101. #define ASM_OUTPUT_LFE(FILE,LINENUM) \
  102.   do {                        \
  103.     int linenum = LINENUM;                \
  104.     MAKE_LINE_SAFE (linenum);            \
  105.     fprintf (FILE, "\t.ef\t%d\n", ABS_OR_RELATIVE_LINENO (linenum)); \
  106.     xcoff_begin_function_line = -1;        \
  107.   } while (0)
  108.  
  109. #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
  110.   do {                        \
  111.     int linenum = LINENUM;                \
  112.     MAKE_LINE_SAFE (linenum);            \
  113.     fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (linenum)); \
  114.   } while (0)
  115.  
  116. #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
  117.   do {                        \
  118.     int linenum = LINENUM;                \
  119.     MAKE_LINE_SAFE (linenum);            \
  120.     fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (linenum)); \
  121.   } while (0)
  122.  
  123. /* Support routines for XCOFF debugging info.  */
  124.  
  125. /* Assign NUMBER as the stabx type number for the type described by NAME.
  126.    Search all decls in the list SYMS to find the type NAME.  */
  127.  
  128. static void
  129. assign_type_number (syms, name, number)
  130.      tree syms;
  131.      char *name;
  132.      int number;
  133. {
  134.   tree decl;
  135.  
  136.   for (decl = syms; decl; decl = TREE_CHAIN (decl))
  137.     if (DECL_NAME (decl)
  138.     && strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name) == 0)
  139.       {
  140.     TREE_ASM_WRITTEN (decl) = 1;
  141.     TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = number;
  142.       }
  143. }
  144.  
  145. /* Setup gcc primitive types to use the XCOFF built-in type numbers where
  146.    possible.  */
  147.  
  148. void
  149. xcoff_output_standard_types (syms)
  150.      tree syms;
  151. {
  152.   /* Handle built-in C types here.  */
  153.  
  154.   assign_type_number (syms, "int", -1);
  155.   assign_type_number (syms, "char", -2);
  156.   assign_type_number (syms, "short int", -3);
  157.   assign_type_number (syms, "long int", -4);
  158.   assign_type_number (syms, "unsigned char", -5);
  159.   assign_type_number (syms, "signed char", -6);
  160.   assign_type_number (syms, "short unsigned int", -7);
  161.   assign_type_number (syms, "unsigned int", -8);
  162.   /* No such type "unsigned".  */
  163.   assign_type_number (syms, "long unsigned int", -10);
  164.   assign_type_number (syms, "void", -11);
  165.   assign_type_number (syms, "float", -12);
  166.   assign_type_number (syms, "double", -13);
  167.   assign_type_number (syms, "long double", -14);
  168.   /* Pascal and Fortran types run from -15 to -29.  */
  169.   /* No such type "wchar".  */
  170.  
  171.   /* "long long int", and "long long unsigned int", are not handled here,
  172.      because there are no predefined types that match them.  */
  173.  
  174.   /* ??? Should also handle built-in C++ and Obj-C types.  There perhaps
  175.      aren't any that C doesn't already have.  */
  176. }
  177.  
  178. /* Print an error message for unrecognized stab codes.  */
  179.  
  180. #define UNKNOWN_STAB(STR)    \
  181.    do { \
  182.      fprintf(stderr, "Error, unknown stab %s: : 0x%x\n", STR, stab); \
  183.      fflush (stderr);    \
  184.    } while (0)
  185.  
  186. /* Conversion routine from BSD stabs to AIX storage classes.  */
  187.  
  188. int
  189. stab_to_sclass (stab)
  190.      int stab;
  191. {
  192.   switch (stab)
  193.     {
  194.     case N_GSYM:
  195.       return C_GSYM;
  196.  
  197.     case N_FNAME:
  198.       UNKNOWN_STAB ("N_FNAME"); 
  199.       abort();
  200.  
  201.     case N_FUN:
  202.       return C_FUN;
  203.  
  204.     case N_STSYM:
  205.     case N_LCSYM:
  206.       return C_STSYM;
  207.  
  208.     case N_MAIN:
  209.       UNKNOWN_STAB ("N_MAIN"); 
  210.       abort ();
  211.  
  212.     case N_RSYM:
  213.       return C_RSYM;
  214.  
  215.     case N_SSYM:
  216.       UNKNOWN_STAB ("N_SSYM"); 
  217.       abort ();
  218.  
  219.     case N_RPSYM:
  220.       return C_RPSYM;
  221.  
  222.     case N_PSYM:
  223.       return C_PSYM;
  224.     case N_LSYM:
  225.       return C_LSYM;
  226.     case N_DECL:
  227.       return C_DECL;
  228.     case N_ENTRY:
  229.       return C_ENTRY;
  230.  
  231.     case N_SO:
  232.       UNKNOWN_STAB ("N_SO"); 
  233.       abort ();
  234.  
  235.     case N_SOL:
  236.       UNKNOWN_STAB ("N_SOL"); 
  237.       abort ();
  238.  
  239.     case N_SLINE:
  240.       UNKNOWN_STAB ("N_SLINE"); 
  241.       abort ();
  242.  
  243.     case N_DSLINE:
  244.       UNKNOWN_STAB ("N_DSLINE"); 
  245.       abort ();
  246.  
  247.     case N_BSLINE:
  248.       UNKNOWN_STAB ("N_BSLINE"); 
  249.       abort ();
  250. #if 0
  251.       /* This has the same value as N_BSLINE.  */
  252.     case N_BROWS:
  253.       UNKNOWN_STAB ("N_BROWS"); 
  254.       abort ();
  255. #endif
  256.  
  257.     case N_BINCL:
  258.       UNKNOWN_STAB ("N_BINCL"); 
  259.       abort ();
  260.  
  261.     case N_EINCL:
  262.       UNKNOWN_STAB ("N_EINCL"); 
  263.       abort ();
  264.  
  265.     case N_EXCL:
  266.       UNKNOWN_STAB ("N_EXCL"); 
  267.       abort ();
  268.  
  269.     case N_LBRAC:
  270.       UNKNOWN_STAB ("N_LBRAC"); 
  271.       abort ();
  272.  
  273.     case N_RBRAC:
  274.       UNKNOWN_STAB ("N_RBRAC"); 
  275.       abort ();
  276.  
  277.     case N_BCOMM:
  278.       return C_BCOMM;
  279.     case N_ECOMM:
  280.       return C_ECOMM;
  281.     case N_ECOML:
  282.       return C_ECOML;
  283.  
  284.     case N_LENG:
  285.       UNKNOWN_STAB ("N_LENG"); 
  286.       abort ();
  287.  
  288.     case N_PC:
  289.       UNKNOWN_STAB ("N_PC"); 
  290.       abort ();
  291.  
  292.     case N_M2C:
  293.       UNKNOWN_STAB ("N_M2C"); 
  294.       abort ();
  295.  
  296.     case N_SCOPE:
  297.       UNKNOWN_STAB ("N_SCOPE"); 
  298.       abort ();
  299.  
  300.     case N_CATCH:
  301.       UNKNOWN_STAB ("N_CATCH"); 
  302.       abort ();
  303.  
  304.     default:
  305.       UNKNOWN_STAB ("default"); 
  306.       abort ();
  307.   }
  308. }
  309.  
  310. /* In XCOFF, we have to have this .bf before the function prologue.
  311.    Rely on the value of `dbx_begin_function_line' not to duplicate .bf.  */
  312.  
  313. void
  314. xcoffout_output_first_source_line (file, last_linenum)
  315.      FILE *file;
  316.      int last_linenum;
  317. {
  318.   ASM_OUTPUT_LFB (file, last_linenum);
  319.   dbxout_parms (DECL_ARGUMENTS (current_function_decl));
  320.   ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
  321. }
  322.  
  323. /* Output the symbols defined in block number DO_BLOCK.
  324.    Set NEXT_BLOCK_NUMBER to 0 before calling.
  325.  
  326.    This function works by walking the tree structure of blocks,
  327.    counting blocks until it finds the desired block.