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