gcc/xcoffout.c

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