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, 2004,
   3    2007, 2008, 2010  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 3, 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 COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 /* Output xcoff-format symbol table data.  The main functionality is contained
  22    in dbxout.c.  This file implements the sdbout-like parts of the xcoff
  23    interface.  Many functions are very similar to their counterparts in
  24    sdbout.c.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "rtl.h"
  32 #include "flags.h"
  33 #include "diagnostic-core.h"
  34 #include "output.h"
  35 #include "ggc.h"
  36 #include "target.h"
  37 #include "debug.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_tls_data_section_name;
  70 char *xcoff_read_only_section_name;
  71
  72 /* Last source file name mentioned in a NOTE insn.  */
  73
  74 const char *xcoff_lastfile;
  75 \f
  76 /* Macro definitions used below.  */
  77
  78 #define ABS_OR_RELATIVE_LINENO(LINENO)          \
  79 ((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
  80
  81 /* Output source line numbers via ".line".  */
  82 #define ASM_OUTPUT_LINE(FILE,LINENUM)                                      \
  83   do                                                                       \
  84     {                                                                      \
  85       /* Make sure we're in a function and prevent output of .line 0, as   \
  86          line # 0 is meant for symbol addresses in xcoff.  Additionally,   \
  87          line numbers are 'unsigned short' in 32-bit mode.  */             \
  88       if (xcoff_begin_function_line >= 0)                                  \
  89         {                                                                  \
  90           int lno = ABS_OR_RELATIVE_LINENO (LINENUM);                      \
  91           if (lno > 0 && (TARGET_64BIT || lno <= (int)USHRT_MAX))          \
  92             fprintf (FILE, "\t.line\t%d\n", lno);                          \
  93         }                                                                  \
  94     }                                                                      \
  95   while (0)
  96
  97 #define ASM_OUTPUT_LFB(FILE,LINENUM) \
  98 {                                               \
  99   if (xcoff_begin_function_line == -1)          \
 100     {                                           \
 101       xcoff_begin_function_line = (LINENUM) - 1;\
 102       fprintf (FILE, "\t.bf\t%d\n", (LINENUM)); \
 103     }                                           \
 104   xcoff_current_function_file                   \
 105     = (xcoff_current_include_file               \
 106        ? xcoff_current_include_file : main_input_filename); \
 107 }
 108
 109 #define ASM_OUTPUT_LFE(FILE,LINENUM)            \
 110   do                                            \
 111     {                                           \
 112       fprintf (FILE, "\t.ef\t%d\n", (LINENUM)); \
 113       xcoff_begin_function_line = -1;           \
 114     }                                           \
 115   while (0)
 116
 117 #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
 118   fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
 119
 120 #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
 121   fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
 122
 123 static void xcoffout_block (tree, int, tree);
 124 static void xcoffout_source_file (FILE *, const char *, int);
 125 \f
 126 /* Support routines for XCOFF debugging info.  */
 127
 128 struct xcoff_type_number
 129 {
 130   const char *name;
 131   int number;
 132 };
 133 static const struct xcoff_type_number xcoff_type_numbers[] = {
 134   { "int", -1 },
 135   { "char", -2 },
 136   { "short int", -3 },
 137   { "long int", -4 },  /* fiddled to -31 if 64 bits */
 138   { "unsigned char", -5 },
 139   { "signed char", -6 },
 140   { "short unsigned int", -7 },
 141   { "unsigned int", -8 },
 142   /* No such type "unsigned".  */
 143   { "long unsigned int", -10 }, /* fiddled to -32 if 64 bits */
 144   { "void", -11 },
 145   { "float", -12 },
 146   { "double", -13 },
 147   { "long double", -14 },
 148   /* Pascal and Fortran types run from -15 to -29.  */
 149   { "wchar", -30 },  /* XXX Should be "wchar_t" ? */
 150   { "long long int", -31 },
 151   { "long long unsigned int", -32 },
 152   /* Additional Fortran types run from -33 to -37.  */
 153
 154   /* ??? Should also handle built-in C++ and Obj-C types.  There perhaps
 155      aren't any that C doesn't already have.  */
 156 };
 157
 158 /* Returns an XCOFF fundamental type number for DECL (assumed to be a
 159    TYPE_DECL), or 0 if dbxout.c should assign a type number normally.  */
 160 int
 161 xcoff_assign_fundamental_type_number (tree decl)
 162 {
 163   const char *name;
 164   size_t i;
 165
 166   /* Do not waste time searching the list for non-intrinsic types.  */
 167   if (DECL_NAME (decl) == 0 || ! DECL_IS_BUILTIN (decl))
 168     return 0;
 169
 170   name = IDENTIFIER_POINTER (DECL_NAME (decl));
 171
 172   /* Linear search, blech, but the list is too small to bother
 173      doing anything else.  */
 174   for (i = 0; i < ARRAY_SIZE (xcoff_type_numbers); i++)
 175     if (!strcmp (xcoff_type_numbers[i].name, name))
 176       goto found;
 177   return 0;
 178
 179  found:
 180   /* -4 and -10 should be replaced with -31 and -32, respectively,
 181      when used for a 64-bit type.  */
 182   if (int_size_in_bytes (TREE_TYPE (decl)) == 8)
 183     {
 184       if (xcoff_type_numbers[i].number == -4)
 185         return -31;
 186       if (xcoff_type_numbers[i].number == -10)
 187         return -32;
 188     }
 189   return xcoff_type_numbers[i].number;
 190 }
 191
 192 /* Print an error message for unrecognized stab codes.  */
 193
 194 #define UNKNOWN_STAB(STR)       \
 195   internal_error ("no sclass for %s stab (0x%x)", STR, stab)
 196
 197 /* Conversion routine from BSD stabs to AIX storage classes.  */
 198
 199 int
 200 stab_to_sclass (int stab)
 201 {
 202   switch (stab)
 203     {
 204     case N_GSYM:
 205       return C_GSYM;
 206
 207     case N_FNAME:
 208       UNKNOWN_STAB ("N_FNAME");
 209
 210     case N_FUN:
 211       return C_FUN;
 212
 213     case N_STSYM:
 214     case N_LCSYM:
 215       return C_STSYM;
 216
 217     case N_MAIN:
 218       UNKNOWN_STAB ("N_MAIN");
 219
 220     case N_RSYM:
 221       return C_RSYM;
 222
 223     case N_SSYM:
 224       UNKNOWN_STAB ("N_SSYM");
 225
 226     case N_RPSYM:
 227       return C_RPSYM;
 228
 229     case N_PSYM:
 230       return C_PSYM;
 231     case N_LSYM:
 232       return C_LSYM;
 233     case N_DECL:
 234       return C_DECL;
 235     case N_ENTRY:
 236       return C_ENTRY;
 237
 238     case N_SO:
 239       UNKNOWN_STAB ("N_SO");
 240
 241     case N_SOL:
 242       UNKNOWN_STAB ("N_SOL");
 243
 244     case N_SLINE:
 245       UNKNOWN_STAB ("N_SLINE");
 246
 247     case N_DSLINE:
 248       UNKNOWN_STAB ("N_DSLINE");
 249
 250     case N_BSLINE:
 251       UNKNOWN_STAB ("N_BSLINE");
 252
 253     case N_BINCL:
 254       UNKNOWN_STAB ("N_BINCL");
 255
 256     case N_EINCL:
 257       UNKNOWN_STAB ("N_EINCL");
 258
 259     case N_EXCL:
 260       UNKNOWN_STAB ("N_EXCL");
 261
 262     case N_LBRAC:
 263       UNKNOWN_STAB ("N_LBRAC");
 264
 265     case N_RBRAC:
 266       UNKNOWN_STAB ("N_RBRAC");
 267
 268     case N_BCOMM:
 269       return C_BCOMM;
 270     case N_ECOMM:
 271       return C_ECOMM;
 272     case N_ECOML:
 273       return C_ECOML;
 274
 275     case N_LENG:
 276       UNKNOWN_STAB ("N_LENG");
 277
 278     case N_PC:
 279       UNKNOWN_STAB ("N_PC");
 280
 281     case N_M2C:
 282       UNKNOWN_STAB ("N_M2C");
 283
 284     case N_SCOPE:
 285       UNKNOWN_STAB ("N_SCOPE");
 286
 287     case N_CATCH:
 288       UNKNOWN_STAB ("N_CATCH");
 289
 290     case N_OPT:
 291       UNKNOWN_STAB ("N_OPT");
 292
 293     default:
 294       UNKNOWN_STAB ("?");
 295     }
 296 }
 297 \f
 298 /* Output debugging info to FILE to switch to sourcefile FILENAME.
 299    INLINE_P is true if this is from an inlined function.  */
 300
 301 static void
 302 xcoffout_source_file (FILE *file, const char *filename, int inline_p)
 303 {
 304   if (filename
 305       && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
 306           || (inline_p && ! xcoff_inlining)
 307           || (! inline_p && xcoff_inlining)))
 308     {
 309       if (xcoff_current_include_file)
 310         {
 311           fprintf (file, "\t.ei\t");
 312           output_quoted_string (file,
 313               remap_debug_filename (xcoff_current_include_file));
 314           fprintf (file, "\n");
 315           xcoff_current_include_file = NULL;
 316         }
 317       xcoff_inlining = inline_p;
 318       if (strcmp (main_input_filename, filename) || inline_p)
 319         {
 320           fprintf (file, "\t.bi\t");
 321           output_quoted_string (file, remap_debug_filename (filename));
 322           fprintf (file, "\n");
 323           xcoff_current_include_file = filename;
 324         }
 325       xcoff_lastfile = filename;
 326     }
 327 }
 328
 329 /* Output a line number symbol entry for location (FILENAME, LINE).  */
 330
 331 void
 332 xcoffout_source_line (unsigned int line, const char *filename,
 333                       int discriminator ATTRIBUTE_UNUSED,
 334                       bool is_stmt ATTRIBUTE_UNUSED)
 335 {
 336   bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
 337                    || (int) line < xcoff_begin_function_line);
 338
 339   xcoffout_source_file (asm_out_file, filename, inline_p);
 340
 341   ASM_OUTPUT_LINE (asm_out_file, line);
 342 }
 343 \f
 344 /* Output the symbols defined in block number DO_BLOCK.
 345
 346    This function works by walking the tree structure of blocks,
 347    counting blocks until it finds the desired block.  */
 348
 349 static int do_block = 0;
 350
 351 static void
 352 xcoffout_block (tree block, int depth, tree args)
 353 {
 354   while (block)
 355     {
 356       /* Ignore blocks never expanded or otherwise marked as real.  */
 357       if (TREE_USED (block))
 358         {
 359           /* When we reach the specified block, output its symbols.  */
 360           if (BLOCK_NUMBER (block) == do_block)
 361             {
 362               /* Output the syms of the block.  */
 363               if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
 364                 dbxout_syms (BLOCK_VARS (block));
 365               if (args)
 366                 dbxout_reg_parms (args);
 367
 368               /* We are now done with the block.  Don't go to inner blocks.  */
 369               return;
 370             }
 371           /* If we are past the specified block, stop the scan.  */
 372           else if (BLOCK_NUMBER (block) >= do_block)
 373             return;
 374
 375           /* Output the subblocks.  */
 376           xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
 377         }
 378       block = BLOCK_CHAIN (block);
 379     }
 380 }
 381
 382 /* Describe the beginning of an internal block within a function.
 383    Also output descriptions of variables defined in this block.
 384
 385    N is the number of the block, by order of beginning, counting from 1,
 386    and not counting the outermost (function top-level) block.
 387    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
 388    if the count starts at 0 for the outermost one.  */
 389
 390 void
 391 xcoffout_begin_block (unsigned int line, unsigned int n)
 392 {
 393   tree decl = current_function_decl;
 394
 395   /* The IBM AIX compiler does not emit a .bb for the function level scope,
 396      so we avoid it here also.  */
 397   if (n != 1)
 398     ASM_OUTPUT_LBB (asm_out_file, line, n);
 399
 400   do_block = n;
 401   xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
 402 }
 403
 404 /* Describe the end line-number of an internal block within a function.  */
 405
 406 void
 407 xcoffout_end_block (unsigned int line, unsigned int n)
 408 {
 409   if (n != 1)
 410     ASM_OUTPUT_LBE (asm_out_file, line, n);
 411 }
 412
 413 /* Called at beginning of function (before prologue).
 414    Declare function as needed for debugging.  */
 415
 416 void
 417 xcoffout_declare_function (FILE *file, tree decl, const char *name)
 418 {
 419   size_t len;
 420
 421   if (*name == '*')
 422     name++;
 423   len = strlen (name);
 424   if (name[len - 1] == ']')
 425     {
 426       char *n = XALLOCAVEC (char, len - 3);
 427       memcpy (n, name, len - 4);
 428       n[len - 4] = '\0';
 429       name = n;
 430     }
 431
 432   /* Any pending .bi or .ei must occur before the .function pseudo op.
 433      Otherwise debuggers will think that the function is in the previous
 434      file and/or at the wrong line number.  */
 435   xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
 436   dbxout_symbol (decl, 0);
 437
 438   /* .function NAME, TOP, MAPPING, TYPE, SIZE
 439      16 and 044 are placeholders for backwards compatibility */
 440   fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
 441            name, name, name, name);
 442 }
 443
 444 /* Called at beginning of function body (at start of prologue).
 445    Record the function's starting line number, so we can output
 446    relative line numbers for the other lines.
 447    Record the file name that this function is contained in.  */
 448
 449 void
 450 xcoffout_begin_prologue (unsigned int line,
 451                          const char *file ATTRIBUTE_UNUSED)
 452 {
 453   ASM_OUTPUT_LFB (asm_out_file, line);
 454   dbxout_parms (DECL_ARGUMENTS (current_function_decl));
 455
 456   /* Emit the symbols for the outermost BLOCK's variables.  sdbout.c does this
 457      in sdbout_begin_block, but there is no guarantee that there will be any
 458      inner block 1, so we must do it here.  This gives a result similar to
 459      dbxout, so it does make some sense.  */
 460   do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
 461   xcoffout_block (DECL_INITIAL (current_function_decl), 0,
 462                   DECL_ARGUMENTS (current_function_decl));
 463
 464   ASM_OUTPUT_LINE (asm_out_file, line);
 465 }
 466
 467 /* Called at end of function (before epilogue).
 468    Describe end of outermost block.  */
 469
 470 void
 471 xcoffout_end_function (unsigned int last_linenum)
 472 {
 473   ASM_OUTPUT_LFE (asm_out_file, last_linenum);
 474 }
 475
 476 /* Output xcoff info for the absolute end of a function.
 477    Called after the epilogue is output.  */
 478
 479 void
 480 xcoffout_end_epilogue (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 */