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