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
 356       if (!xcoff_lastfile)
 357         ggc_add_string_root ((char **) &xcoff_lastfile, 1);
 358
 359       xcoff_lastfile = filename;
 360     }
 361 }
 362
 363 /* Output a line number symbol entry into output stream FILE,
 364    for source file FILENAME and line number NOTE.  */
 365
 366 void
 367 xcoffout_source_line (file, filename, note)
 368      FILE *file;
 369      const char *filename;
 370      rtx note;
 371 {
 372   xcoffout_source_file (file, filename, RTX_INTEGRATED_P (note));
 373
 374   ASM_OUTPUT_SOURCE_LINE (file, NOTE_LINE_NUMBER (note));
 375 }
 376 \f
 377 /* Output the symbols defined in block number DO_BLOCK.
 378
 379    This function works by walking the tree structure of blocks,
 380    counting blocks until it finds the desired block.  */
 381
 382 static int do_block = 0;
 383
 384 static void
 385 xcoffout_block (block, depth, args)
 386      register tree block;
 387      int depth;
 388      tree args;
 389 {
 390   while (block)
 391     {
 392       /* Ignore blocks never expanded or otherwise marked as real.  */
 393       if (TREE_USED (block))
 394         {
 395           /* When we reach the specified block, output its symbols.  */
 396           if (BLOCK_NUMBER (block) == do_block)
 397             {
 398               /* Output the syms of the block.  */
 399               if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
 400                 dbxout_syms (BLOCK_VARS (block));
 401               if (args)
 402                 dbxout_reg_parms (args);
 403
 404               /* We are now done with the block.  Don't go to inner blocks.  */
 405               return;
 406             }
 407           /* If we are past the specified block, stop the scan.  */
 408           else if (BLOCK_NUMBER (block) >= do_block)
 409             return;
 410
 411           /* Output the subblocks.  */
 412           xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
 413         }
 414       block = BLOCK_CHAIN (block);
 415     }
 416 }
 417
 418 /* Describe the beginning of an internal block within a function.
 419    Also output descriptions of variables defined in this block.
 420
 421    N is the number of the block, by order of beginning, counting from 1,
 422    and not counting the outermost (function top-level) block.
 423    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
 424    if the count starts at 0 for the outermost one.  */
 425
 426 void
 427 xcoffout_begin_block (file, line, n)
 428      FILE *file;
 429      int line;
 430      int n;
 431 {
 432   tree decl = current_function_decl;
 433
 434   /* The IBM AIX compiler does not emit a .bb for the function level scope,
 435      so we avoid it here also.  */
 436   if (n != 1)
 437     ASM_OUTPUT_LBB (file, line, n);
 438
 439   do_block = n;
 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      const char *name;
 463 {
 464   int i;
 465
 466   if (*name == '*')
 467     name++;
 468   else
 469     for (i = 0; name[i]; ++i)
 470       {
 471         if (name[i] == '[')
 472           {
 473             char *n = (char *) alloca (i + 1);
 474             strncpy (n, name, i);
 475             n[i] = '\0';
 476             name = n;
 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
 487   /* .function NAME, TOP, MAPPING, TYPE, SIZE
 488      16 and 044 are placeholders for backwards compatibility */
 489   fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
 490            name, name, name, name);
 491 }
 492
 493 /* Called at beginning of function body (after prologue).
 494    Record the function's starting line number, so we can output
 495    relative line numbers for the other lines.
 496    Record the file name that this function is contained in.  */
 497
 498 void
 499 xcoffout_begin_function (file, last_linenum)
 500      FILE *file;
 501      int last_linenum;
 502 {
 503   ASM_OUTPUT_LFB (file, last_linenum);
 504   dbxout_parms (DECL_ARGUMENTS (current_function_decl));
 505
 506   /* Emit the symbols for the outermost BLOCK's variables.  sdbout.c does this
 507      in sdbout_begin_block, but there is no guarantee that there will be any
 508      inner block 1, so we must do it here.  This gives a result similar to
 509      dbxout, so it does make some sense.  */
 510   do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
 511   xcoffout_block (DECL_INITIAL (current_function_decl), 0,
 512                   DECL_ARGUMENTS (current_function_decl));
 513
 514   ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
 515 }
 516
 517 /* Called at end of function (before epilogue).
 518    Describe end of outermost block.  */
 519
 520 void
 521 xcoffout_end_function (file, last_linenum)
 522      FILE *file;
 523      int last_linenum;
 524 {
 525   ASM_OUTPUT_LFE (file, last_linenum);
 526 }
 527
 528 /* Output xcoff info for the absolute end of a function.
 529    Called after the epilogue is output.  */
 530
 531 void
 532 xcoffout_end_epilogue (file)
 533      FILE *file;
 534 {
 535   /* We need to pass the correct function size to .function, otherwise,
 536      the xas assembler can't figure out the correct size for the function
 537      aux entry.  So, we emit a label after the last instruction which can
 538      be used by the .function pseudo op to calculate the function size.  */
 539
 540   const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 541   if (*fname == '*')
 542     ++fname;
 543   fprintf (file, "FE..");
 544   ASM_OUTPUT_LABEL (file, fname);
 545 }
 546 #endif /* XCOFF_DEBUGGING_INFO */