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