gcc/xcoffout.c

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