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