gcc/xcoffout.c

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