gcc/xcoffout.c

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