gcc/xcoffout.c

   1 /* Output xcoff-format symbol table information from GNU compiler.
   2    Copyright (C) 1992, 1994, 1995, 1997, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* Output xcoff-format symbol table data.  The main functionality is contained
  23    in dbxout.c.  This file implements the sdbout-like parts of the xcoff
  24    interface.  Many functions are very similar to their counterparts in
  25    sdbout.c.  */
  26
  27 #include "config.h"
  28
  29 #ifdef XCOFF_DEBUGGING_INFO
  30
  31 #include "system.h"
  32 #include "tree.h"
  33 #include "rtl.h"
  34 #include "flags.h"
  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 /* Line number of beginning of current function, minus one.
  53    Negative means not in a function or not using xcoff.  */
  54
  55 static int xcoff_begin_function_line = -1;
  56 static int xcoff_inlining = 0;
  57
  58 /* Name of the current include file.  */
  59
  60 char *xcoff_current_include_file;
  61
  62 /* Name of the current function file.  This is the file the `.bf' is
  63    emitted from.  In case a line is emitted from a different file,
  64    (by including that file of course), then the line number will be
  65    absolute.  */
  66
  67 static char *xcoff_current_function_file;
  68
  69 /* Names of bss and data sections.  These should be unique names for each
  70    compilation unit.  */
  71
  72 char *xcoff_bss_section_name;
  73 char *xcoff_private_data_section_name;
  74 char *xcoff_read_only_section_name;
  75
  76 /* Last source file name mentioned in a NOTE insn.  */
  77
  78 char *xcoff_lastfile;
  79 \f
  80 /* Macro definitions used below.  */
  81
  82 #define ABS_OR_RELATIVE_LINENO(LINENO)          \
  83 ((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
  84
  85 /* Output source line numbers via ".line" rather than ".stabd".  */
  86 #define ASM_OUTPUT_SOURCE_LINE(FILE,LINENUM) \
  87   do {                                          \
  88     if (xcoff_begin_function_line >= 0)         \
  89       fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
  90   } while (0)
  91
  92 #define ASM_OUTPUT_LFB(FILE,LINENUM) \
  93 {                                               \
  94   if (xcoff_begin_function_line == -1)          \
  95     {                                           \
  96       xcoff_begin_function_line = (LINENUM) - 1;\
  97       fprintf (FILE, "\t.bf\t%d\n", (LINENUM)); \
  98     }                                           \
  99   xcoff_current_function_file                   \
 100     = (xcoff_current_include_file               \
 101        ? xcoff_current_include_file : main_input_filename); \
 102 }
 103
 104 #define ASM_OUTPUT_LFE(FILE,LINENUM) \
 105   do {                                          \
 106     fprintf (FILE, "\t.ef\t%d\n", (LINENUM));   \
 107     xcoff_begin_function_line = -1;             \
 108   } while (0)
 109
 110 #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
 111   fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
 112
 113 #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
 114   fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
 115
 116 static void assign_type_number          PROTO((tree, char *, int));
 117 static void xcoffout_block              PROTO((tree, int, tree));
 118 \f
 119 /* Support routines for XCOFF debugging info.  */
 120
 121 /* Assign NUMBER as the stabx type number for the type described by NAME.
 122    Search all decls in the list SYMS to find the type NAME.  */
 123
 124 static void
 125 assign_type_number (syms, name, number)
 126      tree syms;
 127      char *name;
 128      int number;
 129 {
 130   tree decl;
 131
 132   for (decl = syms; decl; decl = TREE_CHAIN (decl))
 133     if (DECL_NAME (decl)
 134         && strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name) == 0)
 135       {
 136         TREE_ASM_WRITTEN (decl) = 1;
 137         TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = number;
 138       }
 139 }
 140
 141 /* Setup gcc primitive types to use the XCOFF built-in type numbers where
 142    possible.  */
 143
 144 void
 145 xcoff_output_standard_types (syms)
 146      tree syms;
 147 {
 148   /* Handle built-in C types here.  */
 149
 150   assign_type_number (syms, "int", -1);
 151   assign_type_number (syms, "char", -2);
 152   assign_type_number (syms, "short int", -3);
 153   assign_type_number (syms, "long int", (TARGET_64BIT ? -31 : -4));
 154   assign_type_number (syms, "unsigned char", -5);
 155   assign_type_number (syms, "signed char", -6);
 156   assign_type_number (syms, "short unsigned int", -7);
 157   assign_type_number (syms, "unsigned int", -8);
 158   /* No such type "unsigned".  */
 159   assign_type_number (syms, "long unsigned int", (TARGET_64BIT ? -32 : -10));
 160   assign_type_number (syms, "void", -11);
 161   assign_type_number (syms, "float", -12);
 162   assign_type_number (syms, "double", -13);
 163   assign_type_number (syms, "long double", -14);
 164   /* Pascal and Fortran types run from -15 to -29.  */
 165   assign_type_number (syms, "wchar", -30);
 166   assign_type_number (syms, "long long int", -31);
 167   assign_type_number (syms, "long long unsigned int", -32);
 168   /* Additional Fortran types run from -33 to -37.  */
 169
 170   /* ??? Should also handle built-in C++ and Obj-C types.  There perhaps
 171      aren't any that C doesn't already have.  */
 172 }
 173
 174 /* Print an error message for unrecognized stab codes.  */
 175
 176 #define UNKNOWN_STAB(STR)       \
 177    do { \
 178      error ("Unknown stab %s: : 0x%x\n", STR, stab);    \
 179      fflush (stderr);   \
 180    } while (0)
 181
 182 /* Conversion routine from BSD stabs to AIX storage classes.  */
 183
 184 int
 185 stab_to_sclass (stab)
 186      int stab;
 187 {
 188   switch (stab)
 189     {
 190     case N_GSYM:
 191       return C_GSYM;
 192
 193     case N_FNAME:
 194       UNKNOWN_STAB ("N_FNAME");
 195       abort();
 196
 197     case N_FUN:
 198       return C_FUN;
 199
 200     case N_STSYM:
 201     case N_LCSYM:
 202       return C_STSYM;
 203
 204 #ifdef N_MAIN
 205     case N_MAIN:
 206       UNKNOWN_STAB ("N_MAIN");
 207       abort ();
 208 #endif
 209
 210     case N_RSYM:
 211       return C_RSYM;
 212
 213     case N_SSYM:
 214       UNKNOWN_STAB ("N_SSYM");
 215       abort ();
 216
 217     case N_RPSYM:
 218       return C_RPSYM;
 219
 220     case N_PSYM:
 221       return C_PSYM;
 222     case N_LSYM:
 223       return C_LSYM;
 224     case N_DECL:
 225       return C_DECL;
 226     case N_ENTRY:
 227       return C_ENTRY;
 228
 229     case N_SO:
 230       UNKNOWN_STAB ("N_SO");
 231       abort ();
 232
 233     case N_SOL:
 234       UNKNOWN_STAB ("N_SOL");
 235       abort ();
 236
 237     case N_SLINE:
 238       UNKNOWN_STAB ("N_SLINE");
 239       abort ();
 240
 241 #ifdef N_DSLINE
 242     case N_DSLINE:
 243       UNKNOWN_STAB ("N_DSLINE");
 244       abort ();
 245 #endif
 246
 247 #ifdef N_BSLINE
 248     case N_BSLINE:
 249       UNKNOWN_STAB ("N_BSLINE");
 250       abort ();
 251 #endif
 252 #if 0
 253       /* This has the same value as N_BSLINE.  */
 254     case N_BROWS:
 255       UNKNOWN_STAB ("N_BROWS");
 256       abort ();
 257 #endif
 258
 259 #ifdef N_BINCL
 260     case N_BINCL:
 261       UNKNOWN_STAB ("N_BINCL");
 262       abort ();
 263 #endif
 264
 265 #ifdef N_EINCL
 266     case N_EINCL:
 267       UNKNOWN_STAB ("N_EINCL");
 268       abort ();
 269 #endif
 270
 271 #ifdef N_EXCL
 272     case N_EXCL:
 273       UNKNOWN_STAB ("N_EXCL");
 274       abort ();
 275 #endif
 276
 277     case N_LBRAC:
 278       UNKNOWN_STAB ("N_LBRAC");
 279       abort ();
 280
 281     case N_RBRAC:
 282       UNKNOWN_STAB ("N_RBRAC");
 283       abort ();
 284
 285     case N_BCOMM:
 286       return C_BCOMM;
 287     case N_ECOMM:
 288       return C_ECOMM;
 289     case N_ECOML:
 290       return C_ECOML;
 291
 292     case N_LENG:
 293       UNKNOWN_STAB ("N_LENG");
 294       abort ();
 295
 296     case N_PC:
 297       UNKNOWN_STAB ("N_PC");
 298       abort ();
 299
 300 #ifdef N_M2C
 301     case N_M2C:
 302       UNKNOWN_STAB ("N_M2C");
 303       abort ();
 304 #endif
 305
 306 #ifdef N_SCOPE
 307     case N_SCOPE:
 308       UNKNOWN_STAB ("N_SCOPE");
 309       abort ();
 310 #endif
 311
 312     case N_CATCH:
 313       UNKNOWN_STAB ("N_CATCH");
 314       abort ();
 315
 316     default:
 317       UNKNOWN_STAB ("default");
 318       abort ();
 319   }
 320 }
 321 \f
 322 /* Output debugging info to FILE to switch to sourcefile FILENAME.
 323    INLINE_P is true if this is from an inlined function.  */
 324
 325 void
 326 xcoffout_source_file (file, filename, inline_p)
 327      FILE *file;
 328      char *filename;
 329      int inline_p;
 330 {
 331   if (filename
 332       && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
 333           || (inline_p && ! xcoff_inlining)
 334           || (! inline_p && xcoff_inlining)))
 335     {
 336       if (xcoff_current_include_file)
 337         {
 338           fprintf (file, "\t.ei\t");
 339           output_quoted_string (file, xcoff_current_include_file);
 340           fprintf (file, "\n");
 341           xcoff_current_include_file = NULL;
 342         }
 343         xcoff_inlining=inline_p;
 344       if (strcmp (main_input_filename, filename) || inline_p)
 345         {
 346           fprintf (file, "\t.bi\t");
 347           output_quoted_string (file, filename);
 348           fprintf (file, "\n");
 349           xcoff_current_include_file = filename;
 350         }
 351
 352       xcoff_lastfile = filename;
 353     }
 354 }
 355
 356 /* Output a line number symbol entry into output stream FILE,
 357    for source file FILENAME and line number NOTE.  */
 358
 359 void
 360 xcoffout_source_line (file, filename, note)
 361      FILE *file;
 362      char *filename;
 363      rtx note;
 364 {
 365   xcoffout_source_file (file, filename, RTX_INTEGRATED_P (note));
 366
 367   ASM_OUTPUT_SOURCE_LINE (file, NOTE_LINE_NUMBER (note));
 368 }
 369 \f
 370 /* Output the symbols defined in block number DO_BLOCK.
 371    Set NEXT_BLOCK_NUMBER to 0 before calling.
 372
 373    This function works by walking the tree structure of blocks,
 374    counting blocks until it finds the desired block.  */
 375
 376 static int do_block = 0;
 377
 378 static int next_block_number;
 379
 380 static void
 381 xcoffout_block (block, depth, args)
 382      register tree block;
 383      int depth;
 384      tree args;
 385 {
 386   while (block)
 387     {
 388       /* Ignore blocks never expanded or otherwise marked as real.  */
 389       if (TREE_USED (block))
 390         {
 391           /* When we reach the specified block, output its symbols.  */
 392           if (next_block_number == do_block)
 393             {
 394               /* Output the syms of the block.  */
 395               if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
 396                 dbxout_syms (BLOCK_VARS (block));
 397               if (args)
 398                 dbxout_reg_parms (args);
 399
 400               /* We are now done with the block.  Don't go to inner blocks.  */
 401               return;
 402             }
 403           /* If we are past the specified block, stop the scan.  */
 404           else if (next_block_number >= do_block)
 405             return;
 406
 407           next_block_number++;
 408
 409           /* Output the subblocks.  */
 410           xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
 411         }
 412       block = BLOCK_CHAIN (block);
 413     }
 414 }
 415
 416 /* Describe the beginning of an internal block within a function.
 417    Also output descriptions of variables defined in this block.
 418
 419    N is the number of the block, by order of beginning, counting from 1,
 420    and not counting the outermost (function top-level) block.
 421    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
 422    if the count starts at 0 for the outermost one.  */
 423
 424 void
 425 xcoffout_begin_block (file, line, n)
 426      FILE *file;
 427      int line;
 428      int n;
 429 {
 430   tree decl = current_function_decl;
 431
 432
 433   /* The IBM AIX compiler does not emit a .bb for the function level scope,
 434      so we avoid it here also.  */
 435   if (n != 1)
 436     ASM_OUTPUT_LBB (file, line, n);
 437
 438   do_block = n;
 439   next_block_number = 0;
 440   xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
 441 }
 442
 443 /* Describe the end line-number of an internal block within a function.  */
 444
 445 void
 446 xcoffout_end_block (file, line, n)
 447      FILE *file;
 448      int line;
 449      int n;
 450 {
 451   if (n != 1)
 452     ASM_OUTPUT_LBE (file, line, n);
 453 }
 454
 455 /* Called at beginning of function (before prologue).
 456    Declare function as needed for debugging.  */
 457
 458 void
 459 xcoffout_declare_function (file, decl, name)
 460      FILE *file;
 461      tree decl;
 462      char *name;
 463 {
 464   char *n = name;
 465   int i;
 466
 467   if (*n == '*')
 468     n++;
 469   else
 470     for (i = 0; name[i]; ++i)
 471       {
 472         if (name[i] == '[')
 473           {
 474             n = (char *) alloca (i + 1);
 475             strncpy (n, name, i);
 476             n[i] = '\0';
 477             break;
 478           }
 479       }
 480
 481   /* Any pending .bi or .ei must occur before the .function pseudo op.
 482      Otherwise debuggers will think that the function is in the previous
 483      file and/or at the wrong line number.  */
 484   xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
 485   dbxout_symbol (decl, 0);
 486   fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n", n, n, n, n);
 487 }
 488
 489 /* Called at beginning of function body (after prologue).
 490    Record the function's starting line number, so we can output
 491    relative line numbers for the other lines.
 492    Record the file name that this function is contained in.  */
 493
 494 void
 495 xcoffout_begin_function (file, last_linenum)
 496      FILE *file;
 497      int last_linenum;
 498 {
 499   ASM_OUTPUT_LFB (file, last_linenum);
 500   dbxout_parms (DECL_ARGUMENTS (current_function_decl));
 501   ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
 502 }
 503
 504 /* Called at end of function (before epilogue).
 505    Describe end of outermost block.  */
 506
 507 void
 508 xcoffout_end_function (file, last_linenum)
 509      FILE *file;
 510      int last_linenum;
 511 {
 512   ASM_OUTPUT_LFE (file, last_linenum);
 513 }
 514
 515 /* Output xcoff info for the absolute end of a function.
 516    Called after the epilogue is output.  */
 517
 518 void
 519 xcoffout_end_epilogue (file)
 520      FILE *file;
 521 {
 522   /* We need to pass the correct function size to .function, otherwise,
 523      the xas assembler can't figure out the correct size for the function
 524      aux entry.  So, we emit a label after the last instruction which can
 525      be used by the .function pseudo op to calculate the function size.  */
 526
 527   char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 528   if (*fname == '*')
 529     ++fname;
 530   fprintf (file, "FE..");
 531   ASM_OUTPUT_LABEL (file, fname);
 532 }
 533 #endif /* XCOFF_DEBUGGING_INFO */