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