gcc/xcoffout.c

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