gcc/xcoffout.c

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