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