gcc/xcoffout.c

   1 /* Output xcoff-format symbol table information from GNU compiler.
   2    Copyright (C) 1992, 1994, 1995, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC 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, or (at your option)
  10 any later version.
  11
  12 GNU CC 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 GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  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 #include "system.h"
  29 #include "tree.h"
  30 #include "rtl.h"
  31 #include "flags.h"
  32 #include "toplev.h"
  33 #include "output.h"
  34 #include "ggc.h"
  35
  36 #ifdef XCOFF_DEBUGGING_INFO
  37
  38 /* This defines the C_* storage classes.  */
  39 #include <dbxstclass.h>
  40
  41 #include "xcoffout.h"
  42 #include "dbxout.h"
  43
  44 #if defined (USG) || !defined (HAVE_STAB_H)
  45 #include "gstab.h"
  46 #else
  47 #include <stab.h>
  48
  49 /* This is a GNU extension we need to reference in this file.  */
  50 #ifndef N_CATCH
  51 #define N_CATCH 0x54
  52 #endif
  53 #endif
  54
  55 /* Line number of beginning of current function, minus one.
  56    Negative means not in a function or not using xcoff.  */
  57
  58 static int xcoff_begin_function_line = -1;
  59 static int xcoff_inlining = 0;
  60
  61 /* Name of the current include file.  */
  62
  63 const char *xcoff_current_include_file;
  64
  65 /* Name of the current function file.  This is the file the `.bf' is
  66    emitted from.  In case a line is emitted from a different file,
  67    (by including that file of course), then the line number will be
  68    absolute.  */
  69
  70 static const char *xcoff_current_function_file;
  71
  72 /* Names of bss and data sections.  These should be unique names for each
  73    compilation unit.  */
  74
  75 char *xcoff_bss_section_name;
  76 char *xcoff_private_data_section_name;
  77 char *xcoff_read_only_section_name;
  78
  79 /* Last source file name mentioned in a NOTE insn.  */
  80
  81 const char *xcoff_lastfile;
  82 \f
  83 /* Macro definitions used below.  */
  84
  85 #define ABS_OR_RELATIVE_LINENO(LINENO)          \
  86 ((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
  87
  88 /* Output source line numbers via ".line" rather than ".stabd".  */
  89 #define ASM_OUTPUT_SOURCE_LINE(FILE,LINENUM) \
  90   do {                                          \
  91     if (xcoff_begin_function_line >= 0)         \
  92       fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
  93   } while (0)
  94
  95 #define ASM_OUTPUT_LFB(FILE,LINENUM) \
  96 {                                               \
  97   if (xcoff_begin_function_line == -1)          \
  98     {                                           \
  99       xcoff_begin_function_line = (LINENUM) - 1;\
 100       fprintf (FILE, "\t.bf\t%d\n", (LINENUM)); \
 101     }                                           \
 102   xcoff_current_function_file                   \
 103     = (xcoff_current_include_file               \
 104        ? xcoff_current_include_file : main_input_filename); \
 105 }
 106
 107 #define ASM_OUTPUT_LFE(FILE,LINENUM) \
 108   do {                                          \
 109     fprintf (FILE, "\t.ef\t%d\n", (LINENUM));   \
 110     xcoff_begin_function_line = -1;             \
 111   } while (0)
 112
 113 #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
 114   fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
 115
 116 #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
 117   fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
 118
 119 static void assign_type_number          PARAMS ((tree, const char *, int));
 120 static void xcoffout_block              PARAMS ((tree, int, tree));
 121 static void xcoffout_source_file        PARAMS ((FILE *, const char *, int));
 122 \f
 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      const 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", (TARGET_64BIT ? -31 : -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", (TARGET_64BIT ? -32 : -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   assign_type_number (syms, "wchar", -30);
 170   assign_type_number (syms, "long long int", -31);
 171   assign_type_number (syms, "long long unsigned int", -32);
 172   /* Additional Fortran types run from -33 to -37.  */
 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      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 #ifdef N_MAIN
 209     case N_MAIN:
 210       UNKNOWN_STAB ("N_MAIN");
 211       abort ();
 212 #endif
 213
 214     case N_RSYM:
 215       return C_RSYM;
 216
 217     case N_SSYM:
 218       UNKNOWN_STAB ("N_SSYM");
 219       abort ();
 220
 221     case N_RPSYM:
 222       return C_RPSYM;
 223
 224     case N_PSYM:
 225       return C_PSYM;
 226     case N_LSYM:
 227       return C_LSYM;
 228     case N_DECL:
 229       return C_DECL;
 230     case N_ENTRY:
 231       return C_ENTRY;
 232
 233     case N_SO:
 234       UNKNOWN_STAB ("N_SO");
 235       abort ();
 236
 237     case N_SOL:
 238       UNKNOWN_STAB ("N_SOL");
 239       abort ();
 240
 241     case N_SLINE:
 242       UNKNOWN_STAB ("N_SLINE");
 243       abort ();
 244
 245 #ifdef N_DSLINE
 246     case N_DSLINE:
 247       UNKNOWN_STAB ("N_DSLINE");
 248       abort ();
 249 #endif
 250
 251 #ifdef N_BSLINE
 252     case N_BSLINE:
 253       UNKNOWN_STAB ("N_BSLINE");
 254       abort ();
 255 #endif
 256 #if 0
 257       /* This has the same value as N_BSLINE.  */
 258     case N_BROWS:
 259       UNKNOWN_STAB ("N_BROWS");
 260       abort ();
 261 #endif
 262
 263 #ifdef N_BINCL
 264     case N_BINCL:
 265       UNKNOWN_STAB ("N_BINCL");
 266       abort ();
 267 #endif
 268
 269 #ifdef N_EINCL
 270     case N_EINCL:
 271       UNKNOWN_STAB ("N_EINCL");
 272       abort ();
 273 #endif
 274
 275 #ifdef N_EXCL
 276     case N_EXCL:
 277       UNKNOWN_STAB ("N_EXCL");
 278       abort ();
 279 #endif
 280
 281     case N_LBRAC:
 282       UNKNOWN_STAB ("N_LBRAC");
 283       abort ();
 284
 285     case N_RBRAC:
 286       UNKNOWN_STAB ("N_RBRAC");
 287       abort ();
 288
 289     case N_BCOMM:
 290       return C_BCOMM;
 291     case N_ECOMM:
 292       return C_ECOMM;
 293     case N_ECOML:
 294       return C_ECOML;
 295
 296     case N_LENG:
 297       UNKNOWN_STAB ("N_LENG");
 298       abort ();
 299
 300     case N_PC:
 301       UNKNOWN_STAB ("N_PC");
 302       abort ();
 303
 304 #ifdef N_M2C
 305     case N_M2C:
 306       UNKNOWN_STAB ("N_M2C");
 307       abort ();
 308 #endif
 309
 310 #ifdef N_SCOPE
 311     case N_SCOPE:
 312       UNKNOWN_STAB ("N_SCOPE");
 313       abort ();
 314 #endif
 315
 316     case N_CATCH:
 317       UNKNOWN_STAB ("N_CATCH");
 318       abort ();
 319
 320     default:
 321       UNKNOWN_STAB ("default");
 322       abort ();
 323     }
 324 }
 325 \f
 326 /* Output debugging info to FILE to switch to sourcefile FILENAME.
 327    INLINE_P is true if this is from an inlined function.  */
 328
 329 static void
 330 xcoffout_source_file (file, filename, inline_p)
 331      FILE *file;
 332      const char *filename;
 333      int inline_p;
 334 {
 335   if (filename
 336       && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
 337           || (inline_p && ! xcoff_inlining)
 338           || (! inline_p && xcoff_inlining)))
 339     {
 340       if (xcoff_current_include_file)
 341         {
 342           fprintf (file, "\t.ei\t");
 343           output_quoted_string (file, xcoff_current_include_file);
 344           fprintf (file, "\n");
 345           xcoff_current_include_file = NULL;
 346         }
 347       xcoff_inlining = inline_p;
 348       if (strcmp (main_input_filename, filename) || inline_p)
 349         {
 350           fprintf (file, "\t.bi\t");
 351           output_quoted_string (file, filename);
 352           fprintf (file, "\n");
 353           xcoff_current_include_file = filename;
 354         }
 355       xcoff_lastfile = filename;
 356     }
 357 }
 358
 359 /* Output a line number symbol entry into output stream FILE,
 360    for source file FILENAME and line number NOTE.  */
 361
 362 void
 363 xcoffout_source_line (file, filename, note)
 364      FILE *file;
 365      const char *filename;
 366      rtx note;
 367 {
 368   xcoffout_source_file (file, filename, RTX_INTEGRATED_P (note));
 369
 370   ASM_OUTPUT_SOURCE_LINE (file, NOTE_LINE_NUMBER (note));
 371 }
 372 \f
 373 /* Output the symbols defined in block number DO_BLOCK.
 374
 375    This function works by walking the tree structure of blocks,
 376    counting blocks until it finds the desired block.  */
 377
 378 static int do_block = 0;
 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 (BLOCK_NUMBER (block) == 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 (BLOCK_NUMBER (block) >= do_block)
 405             return;
 406
 407           /* Output the subblocks.  */
 408           xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
 409         }
 410       block = BLOCK_CHAIN (block);
 411     }
 412 }
 413
 414 /* Describe the beginning of an internal block within a function.
 415    Also output descriptions of variables defined in this block.
 416
 417    N is the number of the block, by order of beginning, counting from 1,
 418    and not counting the outermost (function top-level) block.
 419    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
 420    if the count starts at 0 for the outermost one.  */
 421
 422 void
 423 xcoffout_begin_block (file, line, n)
 424      FILE *file;
 425      int line;
 426      int n;
 427 {
 428   tree decl = current_function_decl;
 429
 430   /* The IBM AIX compiler does not emit a .bb for the function level scope,
 431      so we avoid it here also.  */
 432   if (n != 1)
 433     ASM_OUTPUT_LBB (file, line, n);
 434
 435   do_block = n;
 436   xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
 437 }
 438
 439 /* Describe the end line-number of an internal block within a function.  */
 440
 441 void
 442 xcoffout_end_block (file, line, n)
 443      FILE *file;
 444      int line;
 445      int n;
 446 {
 447   if (n != 1)
 448     ASM_OUTPUT_LBE (file, line, n);
 449 }
 450
 451 /* Called at beginning of function (before prologue).
 452    Declare function as needed for debugging.  */
 453
 454 void
 455 xcoffout_declare_function (file, decl, name)
 456      FILE *file;
 457      tree decl;
 458      const char *name;
 459 {
 460   int i;
 461
 462   if (*name == '*')
 463     name++;
 464   else
 465     for (i = 0; name[i]; ++i)
 466       {
 467         if (name[i] == '[')
 468           {
 469             char *n = (char *) alloca (i + 1);
 470             strncpy (n, name, i);
 471             n[i] = '\0';
 472             name = n;
 473             break;
 474           }
 475       }
 476
 477   /* Any pending .bi or .ei must occur before the .function pseudo op.
 478      Otherwise debuggers will think that the function is in the previous
 479      file and/or at the wrong line number.  */
 480   xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
 481   dbxout_symbol (decl, 0);
 482
 483   /* .function NAME, TOP, MAPPING, TYPE, SIZE
 484      16 and 044 are placeholders for backwards compatibility */
 485   fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
 486            name, name, name, name);
 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
 502   /* Emit the symbols for the outermost BLOCK's variables.  sdbout.c does this
 503      in sdbout_begin_block, but there is no guarantee that there will be any
 504      inner block 1, so we must do it here.  This gives a result similar to
 505      dbxout, so it does make some sense.  */
 506   do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
 507   xcoffout_block (DECL_INITIAL (current_function_decl), 0,
 508                   DECL_ARGUMENTS (current_function_decl));
 509
 510   ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
 511 }
 512
 513 /* Called at end of function (before epilogue).
 514    Describe end of outermost block.  */
 515
 516 void
 517 xcoffout_end_function (file, last_linenum)
 518      FILE *file;
 519      int last_linenum;
 520 {
 521   ASM_OUTPUT_LFE (file, last_linenum);
 522 }
 523
 524 /* Output xcoff info for the absolute end of a function.
 525    Called after the epilogue is output.  */
 526
 527 void
 528 xcoffout_end_epilogue (file)
 529      FILE *file;
 530 {
 531   /* We need to pass the correct function size to .function, otherwise,
 532      the xas assembler can't figure out the correct size for the function
 533      aux entry.  So, we emit a label after the last instruction which can
 534      be used by the .function pseudo op to calculate the function size.  */
 535
 536   const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 537   if (*fname == '*')
 538     ++fname;
 539   fprintf (file, "FE..");
 540   ASM_OUTPUT_LABEL (file, fname);
 541 }
 542 #endif /* XCOFF_DEBUGGING_INFO */