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