gcc/xcoffout.c

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