gcc/xcoffout.c

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