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