gcc/xcoffout.c

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