gcc/xcoffout.c

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