gcc/xcoffout.c

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