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