ecoff.c revision 1.10
1 /* ECOFF debugging support. 2 Copyright (C) 1993-2025 Free Software Foundation, Inc. 3 Contributed by Cygnus Support. 4 This file was put together by Ian Lance Taylor <ian (at) cygnus.com>. A 5 good deal of it comes directly from mips-tfile.c, by Michael 6 Meissner <meissner (at) osf.org>. 7 8 This file is part of GAS. 9 10 GAS is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3, or (at your option) 13 any later version. 14 15 GAS is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with GAS; see the file COPYING. If not, write to the Free 22 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 23 02110-1301, USA. */ 24 25 #include "as.h" 26 27 /* This file is compiled conditionally for those targets which use 28 ECOFF debugging information (e.g., MIPS ELF, Alpha ECOFF). */ 29 30 #include "ecoff.h" 31 32 #ifdef ECOFF_DEBUGGING 33 34 #include "coff/internal.h" 35 #include "coff/symconst.h" 36 #include "aout/stab_gnu.h" 37 #include "filenames.h" 38 #include "safe-ctype.h" 39 #include "ecoff-bfd.h" 40 41 /* Why isn't this in coff/sym.h? */ 42 #define ST_RFDESCAPE 0xfff 43 44 /* This file constructs the information used by the ECOFF debugging 45 format. It just builds a large block of data. 46 47 We support both ECOFF style debugging and stabs debugging (the 48 stabs symbols are encapsulated in ECOFF symbols). This should let 49 us handle anything the compiler might throw at us. */ 50 51 /* Here is a brief description of the MIPS ECOFF symbol table, by 52 Michael Meissner. The MIPS symbol table has the following pieces: 53 54 Symbolic Header 55 | 56 +-- Auxiliary Symbols 57 | 58 +-- Dense number table 59 | 60 +-- Optimizer Symbols 61 | 62 +-- External Strings 63 | 64 +-- External Symbols 65 | 66 +-- Relative file descriptors 67 | 68 +-- File table 69 | 70 +-- Procedure table 71 | 72 +-- Line number table 73 | 74 +-- Local Strings 75 | 76 +-- Local Symbols 77 78 The symbolic header points to each of the other tables, and also 79 contains the number of entries. It also contains a magic number 80 and MIPS compiler version number, such as 2.0. 81 82 The auxiliary table is a series of 32 bit integers, that are 83 referenced as needed from the local symbol table. Unlike standard 84 COFF, the aux. information does not follow the symbol that uses 85 it, but rather is a separate table. In theory, this would allow 86 the MIPS compilers to collapse duplicate aux. entries, but I've not 87 noticed this happening with the 1.31 compiler suite. The different 88 types of aux. entries are: 89 90 1) dnLow: Low bound on array dimension. 91 92 2) dnHigh: High bound on array dimension. 93 94 3) isym: Index to the local symbol which is the start of the 95 function for the end of function first aux. entry. 96 97 4) width: Width of structures and bitfields. 98 99 5) count: Count of ranges for variant part. 100 101 6) rndx: A relative index into the symbol table. The relative 102 index field has two parts: rfd which is a pointer into the 103 relative file index table or ST_RFDESCAPE which says the next 104 aux. entry is the file number, and index: which is the pointer 105 into the local symbol within a given file table. This is for 106 things like references to types defined in another file. 107 108 7) Type information: This is like the COFF type bits, except it 109 is 32 bits instead of 16; they still have room to add new 110 basic types; and they can handle more than 6 levels of array, 111 pointer, function, etc. Each type information field contains 112 the following structure members: 113 114 a) fBitfield: a bit that says this is a bitfield, and the 115 size in bits follows as the next aux. entry. 116 117 b) continued: a bit that says the next aux. entry is a 118 continuation of the current type information (in case 119 there are more than 6 levels of array/ptr/function). 120 121 c) bt: an integer containing the base type before adding 122 array, pointer, function, etc. qualifiers. The 123 current base types that I have documentation for are: 124 125 btNil -- undefined 126 btAdr -- address - integer same size as ptr 127 btChar -- character 128 btUChar -- unsigned character 129 btShort -- short 130 btUShort -- unsigned short 131 btInt -- int 132 btUInt -- unsigned int 133 btLong -- long 134 btULong -- unsigned long 135 btFloat -- float (real) 136 btDouble -- Double (real) 137 btStruct -- Structure (Record) 138 btUnion -- Union (variant) 139 btEnum -- Enumerated 140 btTypedef -- defined via a typedef isymRef 141 btRange -- subrange of int 142 btSet -- pascal sets 143 btComplex -- fortran complex 144 btDComplex -- fortran double complex 145 btIndirect -- forward or unnamed typedef 146 btFixedDec -- Fixed Decimal 147 btFloatDec -- Float Decimal 148 btString -- Varying Length Character String 149 btBit -- Aligned Bit String 150 btPicture -- Picture 151 btVoid -- Void (MIPS cc revision >= 2.00) 152 153 d) tq0 - tq5: type qualifier fields as needed. The 154 current type qualifier fields I have documentation for 155 are: 156 157 tqNil -- no more qualifiers 158 tqPtr -- pointer 159 tqProc -- procedure 160 tqArray -- array 161 tqFar -- 8086 far pointers 162 tqVol -- volatile 163 164 The dense number table is used in the front ends, and disappears by 165 the time the .o is created. 166 167 With the 1.31 compiler suite, the optimization symbols don't seem 168 to be used as far as I can tell. 169 170 The linker is the first entity that creates the relative file 171 descriptor table, and I believe it is used so that the individual 172 file table pointers don't have to be rewritten when the objects are 173 merged together into the program file. 174 175 Unlike COFF, the basic symbol & string tables are split into 176 external and local symbols/strings. The relocation information 177 only goes off of the external symbol table, and the debug 178 information only goes off of the internal symbol table. The 179 external symbols can have links to an appropriate file index and 180 symbol within the file to give it the appropriate type information. 181 Because of this, the external symbols are actually larger than the 182 internal symbols (to contain the link information), and contain the 183 local symbol structure as a member, though this member is not the 184 first member of the external symbol structure (!). I suspect this 185 split is to make strip easier to deal with. 186 187 Each file table has offsets for where the line numbers, local 188 strings, local symbols, and procedure table starts from within the 189 global tables, and the indices are reset to 0 for each of those 190 tables for the file. 191 192 The procedure table contains the binary equivalents of the .ent 193 (start of the function address), .frame (what register is the 194 virtual frame pointer, constant offset from the register to obtain 195 the VFP, and what register holds the return address), .mask/.fmask 196 (bitmask of saved registers, and where the first register is stored 197 relative to the VFP) assembler directives. It also contains the 198 low and high bounds of the line numbers if debugging is turned on. 199 200 The line number table is a compressed form of the normal COFF line 201 table. Each line number entry is either 1 or 3 bytes long, and 202 contains a signed delta from the previous line, and an unsigned 203 count of the number of instructions this statement takes. 204 205 The local symbol table contains the following fields: 206 207 1) iss: index to the local string table giving the name of the 208 symbol. 209 210 2) value: value of the symbol (address, register number, etc.). 211 212 3) st: symbol type. The current symbol types are: 213 214 stNil -- Nuthin' special 215 stGlobal -- external symbol 216 stStatic -- static 217 stParam -- procedure argument 218 stLocal -- local variable 219 stLabel -- label 220 stProc -- External Procedure 221 stBlock -- beginning of block 222 stEnd -- end (of anything) 223 stMember -- member (of anything) 224 stTypedef -- type definition 225 stFile -- file name 226 stRegReloc -- register relocation 227 stForward -- forwarding address 228 stStaticProc -- Static procedure 229 stConstant -- const 230 231 4) sc: storage class. The current storage classes are: 232 233 scText -- text symbol 234 scData -- initialized data symbol 235 scBss -- un-initialized data symbol 236 scRegister -- value of symbol is register number 237 scAbs -- value of symbol is absolute 238 scUndefined -- who knows? 239 scCdbLocal -- variable's value is IN se->va.?? 240 scBits -- this is a bit field 241 scCdbSystem -- value is IN debugger's address space 242 scRegImage -- register value saved on stack 243 scInfo -- symbol contains debugger information 244 scUserStruct -- addr in struct user for current process 245 scSData -- load time only small data 246 scSBss -- load time only small common 247 scRData -- load time only read only data 248 scVar -- Var parameter (fortranpascal) 249 scCommon -- common variable 250 scSCommon -- small common 251 scVarRegister -- Var parameter in a register 252 scVariant -- Variant record 253 scSUndefined -- small undefined(external) data 254 scInit -- .init section symbol 255 256 5) index: pointer to a local symbol or aux. entry. 257 258 For the following program: 259 260 #include <stdio.h> 261 262 main(){ 263 printf("Hello World!\n"); 264 return 0; 265 } 266 267 Mips-tdump produces the following information: 268 269 Global file header: 270 magic number 0x162 271 # sections 2 272 timestamp 645311799, Wed Jun 13 17:16:39 1990 273 symbolic header offset 284 274 symbolic header size 96 275 optional header 56 276 flags 0x0 277 278 Symbolic header, magic number = 0x7009, vstamp = 1.31: 279 280 Info Offset Number Bytes 281 ==== ====== ====== ===== 282 283 Line numbers 380 4 4 [13] 284 Dense numbers 0 0 0 285 Procedures Tables 384 1 52 286 Local Symbols 436 16 192 287 Optimization Symbols 0 0 0 288 Auxiliary Symbols 628 39 156 289 Local Strings 784 80 80 290 External Strings 864 144 144 291 File Tables 1008 2 144 292 Relative Files 0 0 0 293 External Symbols 1152 20 320 294 295 File #0, "hello2.c" 296 297 Name index = 1 Readin = No 298 Merge = No Endian = LITTLE 299 Debug level = G2 Language = C 300 Adr = 0x00000000 301 302 Info Start Number Size Offset 303 ==== ===== ====== ==== ====== 304 Local strings 0 15 15 784 305 Local symbols 0 6 72 436 306 Line numbers 0 13 13 380 307 Optimization symbols 0 0 0 0 308 Procedures 0 1 52 384 309 Auxiliary symbols 0 14 56 628 310 Relative Files 0 0 0 0 311 312 There are 6 local symbols, starting at 436 313 314 Symbol# 0: "hello2.c" 315 End+1 symbol = 6 316 String index = 1 317 Storage class = Text Index = 6 318 Symbol type = File Value = 0 319 320 Symbol# 1: "main" 321 End+1 symbol = 5 322 Type = int 323 String index = 10 324 Storage class = Text Index = 12 325 Symbol type = Proc Value = 0 326 327 Symbol# 2: "" 328 End+1 symbol = 4 329 String index = 0 330 Storage class = Text Index = 4 331 Symbol type = Block Value = 8 332 333 Symbol# 3: "" 334 First symbol = 2 335 String index = 0 336 Storage class = Text Index = 2 337 Symbol type = End Value = 28 338 339 Symbol# 4: "main" 340 First symbol = 1 341 String index = 10 342 Storage class = Text Index = 1 343 Symbol type = End Value = 52 344 345 Symbol# 5: "hello2.c" 346 First symbol = 0 347 String index = 1 348 Storage class = Text Index = 0 349 Symbol type = End Value = 0 350 351 There are 14 auxiliary table entries, starting at 628. 352 353 * #0 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 354 * #1 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0] 355 * #2 8, [ 8/ 0], [ 2 0:0 0:0:0:0:0:0] 356 * #3 16, [ 16/ 0], [ 4 0:0 0:0:0:0:0:0] 357 * #4 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0] 358 * #5 32, [ 32/ 0], [ 8 0:0 0:0:0:0:0:0] 359 * #6 40, [ 40/ 0], [10 0:0 0:0:0:0:0:0] 360 * #7 44, [ 44/ 0], [11 0:0 0:0:0:0:0:0] 361 * #8 12, [ 12/ 0], [ 3 0:0 0:0:0:0:0:0] 362 * #9 20, [ 20/ 0], [ 5 0:0 0:0:0:0:0:0] 363 * #10 28, [ 28/ 0], [ 7 0:0 0:0:0:0:0:0] 364 * #11 36, [ 36/ 0], [ 9 0:0 0:0:0:0:0:0] 365 #12 5, [ 5/ 0], [ 1 1:0 0:0:0:0:0:0] 366 #13 24, [ 24/ 0], [ 6 0:0 0:0:0:0:0:0] 367 368 There are 1 procedure descriptor entries, starting at 0. 369 370 Procedure descriptor 0: 371 Name index = 10 Name = "main" 372 .mask 0x80000000,-4 .fmask 0x00000000,0 373 .frame $29,24,$31 374 Opt. start = -1 Symbols start = 1 375 First line # = 3 Last line # = 6 376 Line Offset = 0 Address = 0x00000000 377 378 There are 4 bytes holding line numbers, starting at 380. 379 Line 3, delta 0, count 2 380 Line 4, delta 1, count 3 381 Line 5, delta 1, count 2 382 Line 6, delta 1, count 6 383 384 File #1, "/usr/include/stdio.h" 385 386 Name index = 1 Readin = No 387 Merge = Yes Endian = LITTLE 388 Debug level = G2 Language = C 389 Adr = 0x00000000 390 391 Info Start Number Size Offset 392 ==== ===== ====== ==== ====== 393 Local strings 15 65 65 799 394 Local symbols 6 10 120 508 395 Line numbers 0 0 0 380 396 Optimization symbols 0 0 0 0 397 Procedures 1 0 0 436 398 Auxiliary symbols 14 25 100 684 399 Relative Files 0 0 0 0 400 401 There are 10 local symbols, starting at 442 402 403 Symbol# 0: "/usr/include/stdio.h" 404 End+1 symbol = 10 405 String index = 1 406 Storage class = Text Index = 10 407 Symbol type = File Value = 0 408 409 Symbol# 1: "_iobuf" 410 End+1 symbol = 9 411 String index = 22 412 Storage class = Info Index = 9 413 Symbol type = Block Value = 20 414 415 Symbol# 2: "_cnt" 416 Type = int 417 String index = 29 418 Storage class = Info Index = 4 419 Symbol type = Member Value = 0 420 421 Symbol# 3: "_ptr" 422 Type = ptr to char 423 String index = 34 424 Storage class = Info Index = 15 425 Symbol type = Member Value = 32 426 427 Symbol# 4: "_base" 428 Type = ptr to char 429 String index = 39 430 Storage class = Info Index = 16 431 Symbol type = Member Value = 64 432 433 Symbol# 5: "_bufsiz" 434 Type = int 435 String index = 45 436 Storage class = Info Index = 4 437 Symbol type = Member Value = 96 438 439 Symbol# 6: "_flag" 440 Type = short 441 String index = 53 442 Storage class = Info Index = 3 443 Symbol type = Member Value = 128 444 445 Symbol# 7: "_file" 446 Type = char 447 String index = 59 448 Storage class = Info Index = 2 449 Symbol type = Member Value = 144 450 451 Symbol# 8: "" 452 First symbol = 1 453 String index = 0 454 Storage class = Info Index = 1 455 Symbol type = End Value = 0 456 457 Symbol# 9: "/usr/include/stdio.h" 458 First symbol = 0 459 String index = 1 460 Storage class = Text Index = 0 461 Symbol type = End Value = 0 462 463 There are 25 auxiliary table entries, starting at 642. 464 465 * #14 -1, [4095/1048575], [63 1:1 f:f:f:f:f:f] 466 #15 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0] 467 #16 65544, [ 8/ 16], [ 2 0:0 1:0:0:0:0:0] 468 * #17 196656, [ 48/ 48], [12 0:0 3:0:0:0:0:0] 469 * #18 8191, [4095/ 1], [63 1:1 0:0:0:0:f:1] 470 * #19 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0] 471 * #20 20479, [4095/ 4], [63 1:1 0:0:0:0:f:4] 472 * #21 1, [ 1/ 0], [ 0 1:0 0:0:0:0:0:0] 473 * #22 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 474 * #23 2, [ 2/ 0], [ 0 0:1 0:0:0:0:0:0] 475 * #24 160, [ 160/ 0], [40 0:0 0:0:0:0:0:0] 476 * #25 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 477 * #26 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 478 * #27 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 479 * #28 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 480 * #29 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 481 * #30 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 482 * #31 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 483 * #32 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 484 * #33 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 485 * #34 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 486 * #35 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 487 * #36 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 488 * #37 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 489 * #38 0, [ 0/ 0], [ 0 0:0 0:0:0:0:0:0] 490 491 There are 0 procedure descriptor entries, starting at 1. 492 493 There are 20 external symbols, starting at 1152 494 495 Symbol# 0: "_iob" 496 Type = array [3 {160}] of struct _iobuf { ifd = 1, index = 1 } 497 String index = 0 Ifd = 1 498 Storage class = Nil Index = 17 499 Symbol type = Global Value = 60 500 501 Symbol# 1: "fopen" 502 String index = 5 Ifd = 1 503 Storage class = Nil Index = 1048575 504 Symbol type = Proc Value = 0 505 506 Symbol# 2: "fdopen" 507 String index = 11 Ifd = 1 508 Storage class = Nil Index = 1048575 509 Symbol type = Proc Value = 0 510 511 Symbol# 3: "freopen" 512 String index = 18 Ifd = 1 513 Storage class = Nil Index = 1048575 514 Symbol type = Proc Value = 0 515 516 Symbol# 4: "popen" 517 String index = 26 Ifd = 1 518 Storage class = Nil Index = 1048575 519 Symbol type = Proc Value = 0 520 521 Symbol# 5: "tmpfile" 522 String index = 32 Ifd = 1 523 Storage class = Nil Index = 1048575 524 Symbol type = Proc Value = 0 525 526 Symbol# 6: "ftell" 527 String index = 40 Ifd = 1 528 Storage class = Nil Index = 1048575 529 Symbol type = Proc Value = 0 530 531 Symbol# 7: "rewind" 532 String index = 46 Ifd = 1 533 Storage class = Nil Index = 1048575 534 Symbol type = Proc Value = 0 535 536 Symbol# 8: "setbuf" 537 String index = 53 Ifd = 1 538 Storage class = Nil Index = 1048575 539 Symbol type = Proc Value = 0 540 541 Symbol# 9: "setbuffer" 542 String index = 60 Ifd = 1 543 Storage class = Nil Index = 1048575 544 Symbol type = Proc Value = 0 545 546 Symbol# 10: "setlinebuf" 547 String index = 70 Ifd = 1 548 Storage class = Nil Index = 1048575 549 Symbol type = Proc Value = 0 550 551 Symbol# 11: "fgets" 552 String index = 81 Ifd = 1 553 Storage class = Nil Index = 1048575 554 Symbol type = Proc Value = 0 555 556 Symbol# 12: "gets" 557 String index = 87 Ifd = 1 558 Storage class = Nil Index = 1048575 559 Symbol type = Proc Value = 0 560 561 Symbol# 13: "ctermid" 562 String index = 92 Ifd = 1 563 Storage class = Nil Index = 1048575 564 Symbol type = Proc Value = 0 565 566 Symbol# 14: "cuserid" 567 String index = 100 Ifd = 1 568 Storage class = Nil Index = 1048575 569 Symbol type = Proc Value = 0 570 571 Symbol# 15: "tempnam" 572 String index = 108 Ifd = 1 573 Storage class = Nil Index = 1048575 574 Symbol type = Proc Value = 0 575 576 Symbol# 16: "tmpnam" 577 String index = 116 Ifd = 1 578 Storage class = Nil Index = 1048575 579 Symbol type = Proc Value = 0 580 581 Symbol# 17: "sprintf" 582 String index = 123 Ifd = 1 583 Storage class = Nil Index = 1048575 584 Symbol type = Proc Value = 0 585 586 Symbol# 18: "main" 587 Type = int 588 String index = 131 Ifd = 0 589 Storage class = Text Index = 1 590 Symbol type = Proc Value = 0 591 592 Symbol# 19: "printf" 593 String index = 136 Ifd = 0 594 Storage class = Undefined Index = 1048575 595 Symbol type = Proc Value = 0 596 597 The following auxiliary table entries were unused: 598 599 #0 0 0x00000000 void 600 #2 8 0x00000008 char 601 #3 16 0x00000010 short 602 #4 24 0x00000018 int 603 #5 32 0x00000020 long 604 #6 40 0x00000028 float 605 #7 44 0x0000002c double 606 #8 12 0x0000000c unsigned char 607 #9 20 0x00000014 unsigned short 608 #10 28 0x0000001c unsigned int 609 #11 36 0x00000024 unsigned long 610 #14 0 0x00000000 void 611 #15 24 0x00000018 int 612 #19 32 0x00000020 long 613 #20 40 0x00000028 float 614 #21 44 0x0000002c double 615 #22 12 0x0000000c unsigned char 616 #23 20 0x00000014 unsigned short 617 #24 28 0x0000001c unsigned int 618 #25 36 0x00000024 unsigned long 619 #26 48 0x00000030 struct no name { ifd = -1, index = 1048575 } 620 */ 621 622 /* Redefinition of storage classes as an enumeration for better 624 debugging. */ 625 626 typedef enum sc { 627 sc_Nil = scNil, /* no storage class */ 628 sc_Text = scText, /* text symbol */ 629 sc_Data = scData, /* initialized data symbol */ 630 sc_Bss = scBss, /* un-initialized data symbol */ 631 sc_Register = scRegister, /* value of symbol is register number */ 632 sc_Abs = scAbs, /* value of symbol is absolute */ 633 sc_Undefined = scUndefined, /* who knows? */ 634 sc_CdbLocal = scCdbLocal, /* variable's value is IN se->va.?? */ 635 sc_Bits = scBits, /* this is a bit field */ 636 sc_CdbSystem = scCdbSystem, /* value is IN CDB's address space */ 637 sc_RegImage = scRegImage, /* register value saved on stack */ 638 sc_Info = scInfo, /* symbol contains debugger information */ 639 sc_UserStruct = scUserStruct, /* addr in struct user for current process */ 640 sc_SData = scSData, /* load time only small data */ 641 sc_SBss = scSBss, /* load time only small common */ 642 sc_RData = scRData, /* load time only read only data */ 643 sc_Var = scVar, /* Var parameter (fortran,pascal) */ 644 sc_Common = scCommon, /* common variable */ 645 sc_SCommon = scSCommon, /* small common */ 646 sc_VarRegister = scVarRegister, /* Var parameter in a register */ 647 sc_Variant = scVariant, /* Variant record */ 648 sc_SUndefined = scSUndefined, /* small undefined(external) data */ 649 sc_Init = scInit, /* .init section symbol */ 650 sc_Max = scMax /* Max storage class+1 */ 651 } sc_t; 652 653 /* Redefinition of symbol type. */ 654 655 typedef enum st { 656 st_Nil = stNil, /* Nuthin' special */ 657 st_Global = stGlobal, /* external symbol */ 658 st_Static = stStatic, /* static */ 659 st_Param = stParam, /* procedure argument */ 660 st_Local = stLocal, /* local variable */ 661 st_Label = stLabel, /* label */ 662 st_Proc = stProc, /* " " Procedure */ 663 st_Block = stBlock, /* beginning of block */ 664 st_End = stEnd, /* end (of anything) */ 665 st_Member = stMember, /* member (of anything - struct/union/enum */ 666 st_Typedef = stTypedef, /* type definition */ 667 st_File = stFile, /* file name */ 668 st_RegReloc = stRegReloc, /* register relocation */ 669 st_Forward = stForward, /* forwarding address */ 670 st_StaticProc = stStaticProc, /* load time only static procs */ 671 st_Constant = stConstant, /* const */ 672 st_Str = stStr, /* string */ 673 st_Number = stNumber, /* pure number (ie. 4 NOR 2+2) */ 674 st_Expr = stExpr, /* 2+2 vs. 4 */ 675 st_Type = stType, /* post-coercion SER */ 676 st_Max = stMax /* max type+1 */ 677 } st_t; 678 679 /* Redefinition of type qualifiers. */ 680 681 typedef enum tq { 682 tq_Nil = tqNil, /* bt is what you see */ 683 tq_Ptr = tqPtr, /* pointer */ 684 tq_Proc = tqProc, /* procedure */ 685 tq_Array = tqArray, /* duh */ 686 tq_Far = tqFar, /* longer addressing - 8086/8 land */ 687 tq_Vol = tqVol, /* volatile */ 688 tq_Max = tqMax /* Max type qualifier+1 */ 689 } tq_t; 690 691 /* Redefinition of basic types. */ 692 693 typedef enum bt { 694 bt_Nil = btNil, /* undefined */ 695 bt_Adr = btAdr, /* address - integer same size as pointer */ 696 bt_Char = btChar, /* character */ 697 bt_UChar = btUChar, /* unsigned character */ 698 bt_Short = btShort, /* short */ 699 bt_UShort = btUShort, /* unsigned short */ 700 bt_Int = btInt, /* int */ 701 bt_UInt = btUInt, /* unsigned int */ 702 bt_Long = btLong, /* long */ 703 bt_ULong = btULong, /* unsigned long */ 704 bt_Float = btFloat, /* float (real) */ 705 bt_Double = btDouble, /* Double (real) */ 706 bt_Struct = btStruct, /* Structure (Record) */ 707 bt_Union = btUnion, /* Union (variant) */ 708 bt_Enum = btEnum, /* Enumerated */ 709 bt_Typedef = btTypedef, /* defined via a typedef, isymRef points */ 710 bt_Range = btRange, /* subrange of int */ 711 bt_Set = btSet, /* pascal sets */ 712 bt_Complex = btComplex, /* fortran complex */ 713 bt_DComplex = btDComplex, /* fortran double complex */ 714 bt_Indirect = btIndirect, /* forward or unnamed typedef */ 715 bt_FixedDec = btFixedDec, /* Fixed Decimal */ 716 bt_FloatDec = btFloatDec, /* Float Decimal */ 717 bt_String = btString, /* Varying Length Character String */ 718 bt_Bit = btBit, /* Aligned Bit String */ 719 bt_Picture = btPicture, /* Picture */ 720 bt_Void = btVoid, /* Void */ 721 bt_Max = btMax /* Max basic type+1 */ 722 } bt_t; 723 724 #define N_TQ itqMax 725 726 /* States for whether to hash type or not. */ 727 typedef enum hash_state { 728 hash_no = 0, /* Don't hash type */ 729 hash_yes = 1, /* OK to hash type, or use previous hash */ 730 hash_record = 2 /* OK to record hash, but don't use prev. */ 731 } hash_state_t; 732 733 /* Types of different sized allocation requests. */ 734 enum alloc_type { 735 alloc_type_none, /* dummy value */ 736 alloc_type_scope, /* nested scopes linked list */ 737 alloc_type_vlinks, /* glue linking pages in varray */ 738 alloc_type_shash, /* string hash element */ 739 alloc_type_thash, /* type hash element */ 740 alloc_type_tag, /* struct/union/tag element */ 741 alloc_type_forward, /* element to hold unknown tag */ 742 alloc_type_thead, /* head of type hash list */ 743 alloc_type_varray, /* general varray allocation */ 744 alloc_type_lineno, /* line number list */ 745 alloc_type_last /* last+1 element for array bounds */ 746 }; 747 748 /* Types of auxiliary type information. */ 749 enum aux_type { 750 aux_tir, /* TIR type information */ 751 aux_rndx, /* relative index into symbol table */ 752 aux_dnLow, /* low dimension */ 753 aux_dnHigh, /* high dimension */ 754 aux_isym, /* symbol table index (end of proc) */ 755 aux_iss, /* index into string space (not used) */ 756 aux_width, /* width for non-default sized struc fields */ 757 aux_count /* count of ranges for variant arm */ 758 }; 759 760 /* Structures to provide n-number of virtual arrays, each of which can 762 grow linearly, and which are written in the object file as 763 sequential pages. On systems with a BSD malloc, the 764 MAX_CLUSTER_PAGES should be 1 less than a power of two, since 765 malloc adds it's overhead, and rounds up to the next power of 2. 766 Pages are linked together via a linked list. 767 768 If PAGE_SIZE is > 4096, the string length in the shash_t structure 769 can't be represented (assuming there are strings > 4096 bytes). */ 770 771 /* FIXME: Yes, there can be such strings while emitting C++ class debug 772 info. Templates are the offender here, the test case in question 773 having a mangled class name of 774 775 t7rb_tree4Z4xkeyZt4pair2ZC4xkeyZt7xsocket1Z4UserZt9select1st2Zt4pair\ 776 2ZC4xkeyZt7xsocket1Z4UserZ4xkeyZt4less1Z4xkey 777 778 Repeat that a couple dozen times while listing the class members and 779 you've got strings over 4k. Hack around this for now by increasing 780 the page size. A proper solution would abandon this structure scheme 781 certainly for very large strings, and possibly entirely. */ 782 783 #ifndef PAGE_SIZE 784 #define PAGE_SIZE (8*1024) /* size of varray pages */ 785 #endif 786 787 #define PAGE_USIZE ((unsigned long) PAGE_SIZE) 788 789 #ifndef MAX_CLUSTER_PAGES /* # pages to get from system */ 790 #define MAX_CLUSTER_PAGES 63 791 #endif 792 793 /* Linked list connecting separate page allocations. */ 794 typedef struct vlinks { 795 struct vlinks *prev; /* previous set of pages */ 796 struct vlinks *next; /* next set of pages */ 797 union page *datum; /* start of page */ 798 unsigned long start_index; /* starting index # of page */ 799 } vlinks_t; 800 801 /* Virtual array header. */ 802 typedef struct varray { 803 vlinks_t *first; /* first page link */ 804 vlinks_t *last; /* last page link */ 805 unsigned long num_allocated; /* # objects allocated */ 806 unsigned short object_size; /* size in bytes of each object */ 807 unsigned short objects_per_page; /* # objects that can fit on a page */ 808 unsigned short objects_last_page; /* # objects allocated on last page */ 809 } varray_t; 810 811 #ifndef MALLOC_CHECK 812 #define OBJECTS_PER_PAGE(type) (PAGE_SIZE / sizeof (type)) 813 #else 814 #define OBJECTS_PER_PAGE(type) ((sizeof (type) > 1) ? 1 : PAGE_SIZE) 815 #endif 816 817 #define INIT_VARRAY(type) { /* macro to initialize a varray */ \ 818 0, /* first */ \ 819 0, /* last */ \ 820 0, /* num_allocated */ \ 821 sizeof (type), /* object_size */ \ 822 OBJECTS_PER_PAGE (type), /* objects_per_page */ \ 823 OBJECTS_PER_PAGE (type), /* objects_last_page */ \ 824 } 825 826 /* Master type for indexes within the symbol table. */ 827 typedef unsigned long symint_t; 828 829 /* Linked list support for nested scopes (file, block, structure, etc.). */ 830 typedef struct scope { 831 struct scope *prev; /* previous scope level */ 832 struct scope *free; /* free list pointer */ 833 struct localsym *lsym; /* pointer to local symbol node */ 834 st_t type; /* type of the node */ 835 } scope_t; 836 837 /* For a local symbol we store a gas symbol as well as the debugging 838 information we generate. The gas symbol will be NULL if this is 839 only a debugging symbol. */ 840 typedef struct localsym { 841 const char *name; /* symbol name */ 842 symbolS *as_sym; /* symbol as seen by gas */ 843 bfd_vma addend; /* addend to as_sym value */ 844 struct efdr *file_ptr; /* file pointer */ 845 struct ecoff_proc *proc_ptr; /* proc pointer */ 846 struct localsym *begin_ptr; /* symbol at start of block */ 847 struct ecoff_aux *index_ptr; /* index value to be filled in */ 848 struct forward *forward_ref; /* forward references to this symbol */ 849 long sym_index; /* final symbol index */ 850 EXTR ecoff_sym; /* ECOFF debugging symbol */ 851 } localsym_t; 852 853 /* For aux information we keep the type and the data. */ 854 typedef struct ecoff_aux { 855 enum aux_type type; /* aux type */ 856 AUXU data; /* aux data */ 857 } aux_t; 858 859 /* For a procedure we store the gas symbol as well as the PDR 860 debugging information. */ 861 typedef struct ecoff_proc { 862 localsym_t *sym; /* associated symbol */ 863 PDR pdr; /* ECOFF debugging info */ 864 } proc_t; 865 866 /* Number of proc_t structures allocated. */ 867 static unsigned long proc_cnt; 868 869 /* Forward reference list for tags referenced, but not yet defined. */ 870 typedef struct forward { 871 struct forward *next; /* next forward reference */ 872 struct forward *free; /* free list pointer */ 873 aux_t *ifd_ptr; /* pointer to store file index */ 874 aux_t *index_ptr; /* pointer to store symbol index */ 875 } forward_t; 876 877 /* Linked list support for tags. The first tag in the list is always 878 the current tag for that block. */ 879 typedef struct tag { 880 struct tag *free; /* free list pointer */ 881 struct shash *hash_ptr; /* pointer to the hash table head */ 882 struct tag *same_name; /* tag with same name in outer scope */ 883 struct tag *same_block; /* next tag defined in the same block. */ 884 struct forward *forward_ref; /* list of forward references */ 885 bt_t basic_type; /* bt_Struct, bt_Union, or bt_Enum */ 886 symint_t ifd; /* file # tag defined in */ 887 localsym_t *sym; /* file's local symbols */ 888 } tag_t; 889 890 /* Head of a block's linked list of tags. */ 891 typedef struct thead { 892 struct thead *prev; /* previous block */ 893 struct thead *free; /* free list pointer */ 894 struct tag *first_tag; /* first tag in block defined */ 895 } thead_t; 896 897 /* Union containing pointers to each the small structures which are freed up. */ 898 typedef union small_free { 899 scope_t *f_scope; /* scope structure */ 900 thead_t *f_thead; /* tag head structure */ 901 tag_t *f_tag; /* tag element structure */ 902 forward_t *f_forward; /* forward tag reference */ 903 } small_free_t; 904 905 /* String hash table entry. */ 906 907 typedef struct shash { 908 char *string; /* string we are hashing */ 909 symint_t indx; /* index within string table */ 910 EXTR *esym_ptr; /* global symbol pointer */ 911 localsym_t *sym_ptr; /* local symbol pointer */ 912 localsym_t *end_ptr; /* symbol pointer to end block */ 913 tag_t *tag_ptr; /* tag pointer */ 914 proc_t *proc_ptr; /* procedure descriptor pointer */ 915 } shash_t; 916 917 /* Type hash table support. The size of the hash table must fit 918 within a page with the other extended file descriptor information. 919 Because unique types which are hashed are fewer in number than 920 strings, we use a smaller hash value. */ 921 922 #define HASHBITS 30 923 924 #ifndef THASH_SIZE 925 #define THASH_SIZE 113 926 #endif 927 928 typedef struct thash { 929 struct thash *next; /* next hash value */ 930 AUXU type; /* type we are hashing */ 931 symint_t indx; /* index within string table */ 932 } thash_t; 933 934 /* Extended file descriptor that contains all of the support necessary 935 to add things to each file separately. */ 936 typedef struct efdr { 937 FDR fdr; /* File header to be written out */ 938 FDR *orig_fdr; /* original file header */ 939 char *name; /* filename */ 940 int fake; /* whether this is faked .file */ 941 symint_t void_type; /* aux. pointer to 'void' type */ 942 symint_t int_type; /* aux. pointer to 'int' type */ 943 scope_t *cur_scope; /* current nested scopes */ 944 symint_t file_index; /* current file number */ 945 int nested_scopes; /* # nested scopes */ 946 varray_t strings; /* local strings */ 947 varray_t symbols; /* local symbols */ 948 varray_t procs; /* procedures */ 949 varray_t aux_syms; /* auxiliary symbols */ 950 struct efdr *next_file; /* next file descriptor */ 951 /* string/type hash tables */ 952 htab_t str_hash; /* string hash table */ 953 thash_t *thash_head[THASH_SIZE]; 954 } efdr_t; 955 956 /* Pre-initialized extended file structure. */ 957 static const efdr_t init_file = { 958 { /* FDR structure */ 959 0, /* adr: memory address of beginning of file */ 960 0, /* rss: file name (of source, if known) */ 961 0, /* issBase: file's string space */ 962 0, /* cbSs: number of bytes in the ss */ 963 0, /* isymBase: beginning of symbols */ 964 0, /* csym: count file's of symbols */ 965 0, /* ilineBase: file's line symbols */ 966 0, /* cline: count of file's line symbols */ 967 0, /* ioptBase: file's optimization entries */ 968 0, /* copt: count of file's optimization entries */ 969 0, /* ipdFirst: start of procedures for this file */ 970 0, /* cpd: count of procedures for this file */ 971 0, /* iauxBase: file's auxiliary entries */ 972 0, /* caux: count of file's auxiliary entries */ 973 0, /* rfdBase: index into the file indirect table */ 974 0, /* crfd: count file indirect entries */ 975 langC, /* lang: language for this file */ 976 1, /* fMerge: whether this file can be merged */ 977 0, /* fReadin: true if read in (not just created) */ 978 TARGET_BYTES_BIG_ENDIAN, /* fBigendian: if 1, compiled on big endian machine */ 979 GLEVEL_2, /* glevel: level this file was compiled with */ 980 0, /* reserved: reserved for future use */ 981 0, /* cbLineOffset: byte offset from header for this file ln's */ 982 0, /* cbLine: size of lines for this file */ 983 }, 984 985 0, /* orig_fdr: original file header pointer */ 986 0, /* name: pointer to filename */ 987 0, /* fake: whether this is a faked .file */ 988 0, /* void_type: ptr to aux node for void type */ 989 0, /* int_type: ptr to aux node for int type */ 990 0, /* cur_scope: current scope being processed */ 991 0, /* file_index: current file # */ 992 0, /* nested_scopes: # nested scopes */ 993 INIT_VARRAY (char), /* strings: local string varray */ 994 INIT_VARRAY (localsym_t), /* symbols: local symbols varray */ 995 INIT_VARRAY (proc_t), /* procs: procedure varray */ 996 INIT_VARRAY (aux_t), /* aux_syms: auxiliary symbols varray */ 997 998 0, /* next_file: next file structure */ 999 1000 0, /* str_hash: string hash table */ 1001 { 0 }, /* thash_head: type hash table */ 1002 }; 1003 1004 static efdr_t *first_file; /* first file descriptor */ 1005 static efdr_t **last_file_ptr = &first_file; /* file descriptor tail */ 1006 1007 /* Line number information is kept in a list until the assembly is 1008 finished. */ 1009 typedef struct lineno_list { 1010 struct lineno_list *next; /* next element in list */ 1011 efdr_t *file; /* file this line is in */ 1012 proc_t *proc; /* procedure this line is in */ 1013 fragS *frag; /* fragment this line number is in */ 1014 unsigned long paddr; /* offset within fragment */ 1015 long lineno; /* actual line number */ 1016 } lineno_list_t; 1017 1018 static lineno_list_t *first_lineno; 1019 static lineno_list_t *last_lineno; 1020 static lineno_list_t **last_lineno_ptr = &first_lineno; 1021 1022 /* Sometimes there will be some .loc statements before a .ent. We 1023 keep them in this list so that we can fill in the procedure pointer 1024 after we see the .ent. */ 1025 static lineno_list_t *noproc_lineno; 1026 1027 /* Union of various things that are held in pages. */ 1028 typedef union page { 1029 char byte [ PAGE_SIZE ]; 1030 unsigned char ubyte [ PAGE_SIZE ]; 1031 efdr_t file [ PAGE_SIZE / sizeof (efdr_t) ]; 1032 FDR ofile [ PAGE_SIZE / sizeof (FDR) ]; 1033 proc_t proc [ PAGE_SIZE / sizeof (proc_t) ]; 1034 localsym_t sym [ PAGE_SIZE / sizeof (localsym_t) ]; 1035 aux_t aux [ PAGE_SIZE / sizeof (aux_t) ]; 1036 DNR dense [ PAGE_SIZE / sizeof (DNR) ]; 1037 scope_t scope [ PAGE_SIZE / sizeof (scope_t) ]; 1038 vlinks_t vlinks [ PAGE_SIZE / sizeof (vlinks_t) ]; 1039 shash_t shash [ PAGE_SIZE / sizeof (shash_t) ]; 1040 thash_t thash [ PAGE_SIZE / sizeof (thash_t) ]; 1041 tag_t tag [ PAGE_SIZE / sizeof (tag_t) ]; 1042 forward_t forward [ PAGE_SIZE / sizeof (forward_t) ]; 1043 thead_t thead [ PAGE_SIZE / sizeof (thead_t) ]; 1044 lineno_list_t lineno [ PAGE_SIZE / sizeof (lineno_list_t) ]; 1045 } page_type; 1046 1047 /* Structure holding allocation information for small sized structures. */ 1048 typedef struct alloc_info { 1049 char *alloc_name; /* name of this allocation type (must be first) */ 1050 page_type *cur_page; /* current page being allocated from */ 1051 small_free_t free_list; /* current free list if any */ 1052 int unallocated; /* number of elements unallocated on page */ 1053 int total_alloc; /* total number of allocations */ 1054 int total_free; /* total number of frees */ 1055 int total_pages; /* total number of pages allocated */ 1056 } alloc_info_t; 1057 1058 /* Type information collected together. */ 1059 typedef struct type_info { 1060 bt_t basic_type; /* basic type */ 1061 int orig_type; /* original COFF-based type */ 1062 int num_tq; /* # type qualifiers */ 1063 int num_dims; /* # dimensions */ 1064 int num_sizes; /* # sizes */ 1065 int extra_sizes; /* # extra sizes not tied with dims */ 1066 tag_t * tag_ptr; /* tag pointer */ 1067 int bitfield; /* symbol is a bitfield */ 1068 tq_t type_qualifiers[N_TQ]; /* type qualifiers (ptr, func, array)*/ 1069 symint_t dimensions [N_TQ]; /* dimensions for each array */ 1070 symint_t sizes [N_TQ+2]; /* sizes of each array slice + size of 1071 struct/union/enum + bitfield size */ 1072 } type_info_t; 1073 1074 /* Pre-initialized type_info struct. */ 1075 static const type_info_t type_info_init = { 1076 bt_Nil, /* basic type */ 1077 T_NULL, /* original COFF-based type */ 1078 0, /* # type qualifiers */ 1079 0, /* # dimensions */ 1080 0, /* # sizes */ 1081 0, /* sizes not tied with dims */ 1082 NULL, /* ptr to tag */ 1083 0, /* bitfield */ 1084 { /* type qualifiers */ 1085 tq_Nil, 1086 tq_Nil, 1087 tq_Nil, 1088 tq_Nil, 1089 tq_Nil, 1090 tq_Nil, 1091 }, 1092 { /* dimensions */ 1093 0, 1094 0, 1095 0, 1096 0, 1097 0, 1098 0 1099 }, 1100 { /* sizes */ 1101 0, 1102 0, 1103 0, 1104 0, 1105 0, 1106 0, 1107 0, 1108 0, 1109 }, 1110 }; 1111 1112 /* Global hash table for the tags table and global table for file 1113 descriptors. */ 1114 1115 static varray_t file_desc = INIT_VARRAY (efdr_t); 1116 1117 static htab_t tag_hash; 1118 1119 /* Static types for int and void. Also, remember the last function's 1120 type (which is set up when we encounter the declaration for the 1121 function, and used when the end block for the function is emitted. */ 1122 1123 static type_info_t int_type_info; 1124 static type_info_t void_type_info; 1125 static type_info_t last_func_type_info; 1126 static symbolS *last_func_sym_value; 1127 1128 /* Convert COFF basic type to ECOFF basic type. The T_NULL type 1129 really should use bt_Void, but this causes the current ecoff GDB to 1130 issue unsupported type messages, and the Ultrix 4.00 dbx (aka MIPS 1131 2.0) doesn't understand it, even though the compiler generates it. 1132 Maybe this will be fixed in 2.10 or 2.20 of the MIPS compiler 1133 suite, but for now go with what works. 1134 1135 It would make sense for the .type and .scl directives to use the 1136 ECOFF numbers directly, rather than using the COFF numbers and 1137 mapping them. Unfortunately, this is historically what mips-tfile 1138 expects, and changing gcc now would be a considerable pain (the 1139 native compiler generates debugging information internally, rather 1140 than via the assembler, so it will never use .type or .scl). */ 1141 1142 static const bt_t map_coff_types[] = { 1143 bt_Nil, /* T_NULL */ 1144 bt_Nil, /* T_ARG */ 1145 bt_Char, /* T_CHAR */ 1146 bt_Short, /* T_SHORT */ 1147 bt_Int, /* T_INT */ 1148 bt_Long, /* T_LONG */ 1149 bt_Float, /* T_FLOAT */ 1150 bt_Double, /* T_DOUBLE */ 1151 bt_Struct, /* T_STRUCT */ 1152 bt_Union, /* T_UNION */ 1153 bt_Enum, /* T_ENUM */ 1154 bt_Enum, /* T_MOE */ 1155 bt_UChar, /* T_UCHAR */ 1156 bt_UShort, /* T_USHORT */ 1157 bt_UInt, /* T_UINT */ 1158 bt_ULong /* T_ULONG */ 1159 }; 1160 1161 /* Convert COFF storage class to ECOFF storage class. */ 1162 static const sc_t map_coff_storage[] = { 1163 sc_Nil, /* 0: C_NULL */ 1164 sc_Abs, /* 1: C_AUTO auto var */ 1165 sc_Undefined, /* 2: C_EXT external */ 1166 sc_Data, /* 3: C_STAT static */ 1167 sc_Register, /* 4: C_REG register */ 1168 sc_Undefined, /* 5: C_EXTDEF ??? */ 1169 sc_Text, /* 6: C_LABEL label */ 1170 sc_Text, /* 7: C_ULABEL user label */ 1171 sc_Info, /* 8: C_MOS member of struct */ 1172 sc_Abs, /* 9: C_ARG argument */ 1173 sc_Info, /* 10: C_STRTAG struct tag */ 1174 sc_Info, /* 11: C_MOU member of union */ 1175 sc_Info, /* 12: C_UNTAG union tag */ 1176 sc_Info, /* 13: C_TPDEF typedef */ 1177 sc_Data, /* 14: C_USTATIC ??? */ 1178 sc_Info, /* 15: C_ENTAG enum tag */ 1179 sc_Info, /* 16: C_MOE member of enum */ 1180 sc_Register, /* 17: C_REGPARM register parameter */ 1181 sc_Bits, /* 18; C_FIELD bitfield */ 1182 sc_Nil, /* 19 */ 1183 sc_Nil, /* 20 */ 1184 sc_Nil, /* 21 */ 1185 sc_Nil, /* 22 */ 1186 sc_Nil, /* 23 */ 1187 sc_Nil, /* 24 */ 1188 sc_Nil, /* 25 */ 1189 sc_Nil, /* 26 */ 1190 sc_Nil, /* 27 */ 1191 sc_Nil, /* 28 */ 1192 sc_Nil, /* 29 */ 1193 sc_Nil, /* 30 */ 1194 sc_Nil, /* 31 */ 1195 sc_Nil, /* 32 */ 1196 sc_Nil, /* 33 */ 1197 sc_Nil, /* 34 */ 1198 sc_Nil, /* 35 */ 1199 sc_Nil, /* 36 */ 1200 sc_Nil, /* 37 */ 1201 sc_Nil, /* 38 */ 1202 sc_Nil, /* 39 */ 1203 sc_Nil, /* 40 */ 1204 sc_Nil, /* 41 */ 1205 sc_Nil, /* 42 */ 1206 sc_Nil, /* 43 */ 1207 sc_Nil, /* 44 */ 1208 sc_Nil, /* 45 */ 1209 sc_Nil, /* 46 */ 1210 sc_Nil, /* 47 */ 1211 sc_Nil, /* 48 */ 1212 sc_Nil, /* 49 */ 1213 sc_Nil, /* 50 */ 1214 sc_Nil, /* 51 */ 1215 sc_Nil, /* 52 */ 1216 sc_Nil, /* 53 */ 1217 sc_Nil, /* 54 */ 1218 sc_Nil, /* 55 */ 1219 sc_Nil, /* 56 */ 1220 sc_Nil, /* 57 */ 1221 sc_Nil, /* 58 */ 1222 sc_Nil, /* 59 */ 1223 sc_Nil, /* 60 */ 1224 sc_Nil, /* 61 */ 1225 sc_Nil, /* 62 */ 1226 sc_Nil, /* 63 */ 1227 sc_Nil, /* 64 */ 1228 sc_Nil, /* 65 */ 1229 sc_Nil, /* 66 */ 1230 sc_Nil, /* 67 */ 1231 sc_Nil, /* 68 */ 1232 sc_Nil, /* 69 */ 1233 sc_Nil, /* 70 */ 1234 sc_Nil, /* 71 */ 1235 sc_Nil, /* 72 */ 1236 sc_Nil, /* 73 */ 1237 sc_Nil, /* 74 */ 1238 sc_Nil, /* 75 */ 1239 sc_Nil, /* 76 */ 1240 sc_Nil, /* 77 */ 1241 sc_Nil, /* 78 */ 1242 sc_Nil, /* 79 */ 1243 sc_Nil, /* 80 */ 1244 sc_Nil, /* 81 */ 1245 sc_Nil, /* 82 */ 1246 sc_Nil, /* 83 */ 1247 sc_Nil, /* 84 */ 1248 sc_Nil, /* 85 */ 1249 sc_Nil, /* 86 */ 1250 sc_Nil, /* 87 */ 1251 sc_Nil, /* 88 */ 1252 sc_Nil, /* 89 */ 1253 sc_Nil, /* 90 */ 1254 sc_Nil, /* 91 */ 1255 sc_Nil, /* 92 */ 1256 sc_Nil, /* 93 */ 1257 sc_Nil, /* 94 */ 1258 sc_Nil, /* 95 */ 1259 sc_Nil, /* 96 */ 1260 sc_Nil, /* 97 */ 1261 sc_Nil, /* 98 */ 1262 sc_Nil, /* 99 */ 1263 sc_Text, /* 100: C_BLOCK block start/end */ 1264 sc_Text, /* 101: C_FCN function start/end */ 1265 sc_Info, /* 102: C_EOS end of struct/union/enum */ 1266 sc_Nil, /* 103: C_FILE file start */ 1267 sc_Nil, /* 104: C_LINE line number */ 1268 sc_Nil, /* 105: C_ALIAS combined type info */ 1269 sc_Nil, /* 106: C_HIDDEN ??? */ 1270 }; 1271 1272 /* Convert COFF storage class to ECOFF symbol type. */ 1273 static const st_t map_coff_sym_type[] = { 1274 st_Nil, /* 0: C_NULL */ 1275 st_Local, /* 1: C_AUTO auto var */ 1276 st_Global, /* 2: C_EXT external */ 1277 st_Static, /* 3: C_STAT static */ 1278 st_Local, /* 4: C_REG register */ 1279 st_Global, /* 5: C_EXTDEF ??? */ 1280 st_Label, /* 6: C_LABEL label */ 1281 st_Label, /* 7: C_ULABEL user label */ 1282 st_Member, /* 8: C_MOS member of struct */ 1283 st_Param, /* 9: C_ARG argument */ 1284 st_Block, /* 10: C_STRTAG struct tag */ 1285 st_Member, /* 11: C_MOU member of union */ 1286 st_Block, /* 12: C_UNTAG union tag */ 1287 st_Typedef, /* 13: C_TPDEF typedef */ 1288 st_Static, /* 14: C_USTATIC ??? */ 1289 st_Block, /* 15: C_ENTAG enum tag */ 1290 st_Member, /* 16: C_MOE member of enum */ 1291 st_Param, /* 17: C_REGPARM register parameter */ 1292 st_Member, /* 18; C_FIELD bitfield */ 1293 st_Nil, /* 19 */ 1294 st_Nil, /* 20 */ 1295 st_Nil, /* 21 */ 1296 st_Nil, /* 22 */ 1297 st_Nil, /* 23 */ 1298 st_Nil, /* 24 */ 1299 st_Nil, /* 25 */ 1300 st_Nil, /* 26 */ 1301 st_Nil, /* 27 */ 1302 st_Nil, /* 28 */ 1303 st_Nil, /* 29 */ 1304 st_Nil, /* 30 */ 1305 st_Nil, /* 31 */ 1306 st_Nil, /* 32 */ 1307 st_Nil, /* 33 */ 1308 st_Nil, /* 34 */ 1309 st_Nil, /* 35 */ 1310 st_Nil, /* 36 */ 1311 st_Nil, /* 37 */ 1312 st_Nil, /* 38 */ 1313 st_Nil, /* 39 */ 1314 st_Nil, /* 40 */ 1315 st_Nil, /* 41 */ 1316 st_Nil, /* 42 */ 1317 st_Nil, /* 43 */ 1318 st_Nil, /* 44 */ 1319 st_Nil, /* 45 */ 1320 st_Nil, /* 46 */ 1321 st_Nil, /* 47 */ 1322 st_Nil, /* 48 */ 1323 st_Nil, /* 49 */ 1324 st_Nil, /* 50 */ 1325 st_Nil, /* 51 */ 1326 st_Nil, /* 52 */ 1327 st_Nil, /* 53 */ 1328 st_Nil, /* 54 */ 1329 st_Nil, /* 55 */ 1330 st_Nil, /* 56 */ 1331 st_Nil, /* 57 */ 1332 st_Nil, /* 58 */ 1333 st_Nil, /* 59 */ 1334 st_Nil, /* 60 */ 1335 st_Nil, /* 61 */ 1336 st_Nil, /* 62 */ 1337 st_Nil, /* 63 */ 1338 st_Nil, /* 64 */ 1339 st_Nil, /* 65 */ 1340 st_Nil, /* 66 */ 1341 st_Nil, /* 67 */ 1342 st_Nil, /* 68 */ 1343 st_Nil, /* 69 */ 1344 st_Nil, /* 70 */ 1345 st_Nil, /* 71 */ 1346 st_Nil, /* 72 */ 1347 st_Nil, /* 73 */ 1348 st_Nil, /* 74 */ 1349 st_Nil, /* 75 */ 1350 st_Nil, /* 76 */ 1351 st_Nil, /* 77 */ 1352 st_Nil, /* 78 */ 1353 st_Nil, /* 79 */ 1354 st_Nil, /* 80 */ 1355 st_Nil, /* 81 */ 1356 st_Nil, /* 82 */ 1357 st_Nil, /* 83 */ 1358 st_Nil, /* 84 */ 1359 st_Nil, /* 85 */ 1360 st_Nil, /* 86 */ 1361 st_Nil, /* 87 */ 1362 st_Nil, /* 88 */ 1363 st_Nil, /* 89 */ 1364 st_Nil, /* 90 */ 1365 st_Nil, /* 91 */ 1366 st_Nil, /* 92 */ 1367 st_Nil, /* 93 */ 1368 st_Nil, /* 94 */ 1369 st_Nil, /* 95 */ 1370 st_Nil, /* 96 */ 1371 st_Nil, /* 97 */ 1372 st_Nil, /* 98 */ 1373 st_Nil, /* 99 */ 1374 st_Block, /* 100: C_BLOCK block start/end */ 1375 st_Proc, /* 101: C_FCN function start/end */ 1376 st_End, /* 102: C_EOS end of struct/union/enum */ 1377 st_File, /* 103: C_FILE file start */ 1378 st_Nil, /* 104: C_LINE line number */ 1379 st_Nil, /* 105: C_ALIAS combined type info */ 1380 st_Nil, /* 106: C_HIDDEN ??? */ 1381 }; 1382 1383 /* Keep track of different sized allocation requests. */ 1384 static alloc_info_t alloc_counts[alloc_type_last]; 1385 1386 /* Record whether we have seen any debugging information. */ 1388 int ecoff_debugging_seen = 0; 1389 1390 /* Various statics. */ 1391 static efdr_t *cur_file_ptr = 0; /* current file desc. header */ 1392 static proc_t *cur_proc_ptr = 0; /* current procedure header */ 1393 static proc_t *first_proc_ptr = 0; /* first procedure header */ 1394 static thead_t *top_tag_head = 0; /* top level tag head */ 1395 static thead_t *cur_tag_head = 0; /* current tag head */ 1396 #ifdef ECOFF_DEBUG 1397 static int debug = 0; /* trace functions */ 1398 #endif 1399 static int stabs_seen = 0; /* != 0 if stabs have been seen */ 1400 1401 static int current_file_idx; 1402 static const char *current_stabs_filename; 1403 1404 /* Pseudo symbol to use when putting stabs into the symbol table. */ 1405 #ifndef STABS_SYMBOL 1406 #define STABS_SYMBOL "@stabs" 1407 #endif 1408 1409 static char stabs_symbol[] = STABS_SYMBOL; 1410 1411 /* Prototypes for functions defined in this file. */ 1413 1414 static void add_varray_page (varray_t *vp); 1415 static symint_t add_string (varray_t *vp, 1416 htab_t hash_tbl, 1417 const char *str, 1418 shash_t **ret_hash); 1419 static localsym_t *add_ecoff_symbol (const char *str, st_t type, 1420 sc_t storage, symbolS *sym, 1421 bfd_vma addend, symint_t value, 1422 symint_t indx); 1423 static symint_t add_aux_sym_symint (symint_t aux_word); 1424 static symint_t add_aux_sym_rndx (int file_index, symint_t sym_index); 1425 static symint_t add_aux_sym_tir (type_info_t *t, 1426 hash_state_t state, 1427 thash_t **hash_tbl); 1428 static tag_t *get_tag (const char *tag, localsym_t *sym, bt_t basic_type); 1429 static void add_unknown_tag (tag_t *ptag); 1430 static void add_procedure (char *func, int aent); 1431 static void add_file (const char *file_name, int indx, int fake); 1432 #ifdef ECOFF_DEBUG 1433 static char *sc_to_string (sc_t storage_class); 1434 static char *st_to_string (st_t symbol_type); 1435 #endif 1436 static void mark_stabs (int); 1437 static char *ecoff_add_bytes (char **buf, char **bufend, 1438 char *bufptr, unsigned long need); 1439 static unsigned long ecoff_padding_adjust 1440 (const struct ecoff_debug_swap *backend, char **buf, char **bufend, 1441 unsigned long offset, char **bufptrptr); 1442 static unsigned long ecoff_build_lineno 1443 (const struct ecoff_debug_swap *backend, char **buf, char **bufend, 1444 unsigned long offset, long *linecntptr); 1445 static unsigned long ecoff_build_symbols 1446 (const struct ecoff_debug_swap *backend, char **buf, char **bufend, 1447 unsigned long offset); 1448 static unsigned long ecoff_build_procs 1449 (const struct ecoff_debug_swap *backend, char **buf, char **bufend, 1450 unsigned long offset); 1451 static unsigned long ecoff_build_aux 1452 (const struct ecoff_debug_swap *backend, char **buf, char **bufend, 1453 unsigned long offset); 1454 static unsigned long ecoff_build_strings (char **buf, char **bufend, 1455 unsigned long offset, 1456 varray_t *vp); 1457 static unsigned long ecoff_build_ss 1458 (const struct ecoff_debug_swap *backend, char **buf, char **bufend, 1459 unsigned long offset); 1460 static unsigned long ecoff_build_fdr 1461 (const struct ecoff_debug_swap *backend, char **buf, char **bufend, 1462 unsigned long offset); 1463 static void ecoff_setup_ext (void); 1464 static page_type *allocate_cluster (unsigned long npages); 1465 static page_type *allocate_page (void); 1466 static scope_t *allocate_scope (void); 1467 static void free_scope (scope_t *ptr); 1468 static vlinks_t *allocate_vlinks (void); 1469 static shash_t *allocate_shash (void); 1470 static thash_t *allocate_thash (void); 1471 static tag_t *allocate_tag (void); 1472 static void free_tag (tag_t *ptr); 1473 static forward_t *allocate_forward (void); 1474 static thead_t *allocate_thead (void); 1475 static void free_thead (thead_t *ptr); 1476 static lineno_list_t *allocate_lineno_list (void); 1477 1478 /* This function should be called when the assembler starts up. */ 1480 1481 void 1482 ecoff_read_begin_hook (void) 1483 { 1484 tag_hash = str_htab_create (); 1485 top_tag_head = allocate_thead (); 1486 top_tag_head->first_tag = NULL; 1487 top_tag_head->free = NULL; 1488 top_tag_head->prev = cur_tag_head; 1489 cur_tag_head = top_tag_head; 1490 } 1491 1492 /* This function should be called when a symbol is created. */ 1493 1494 void 1495 ecoff_symbol_new_hook (symbolS *symbolP) 1496 { 1497 OBJ_SYMFIELD_TYPE *obj; 1498 1499 /* Make sure that we have a file pointer, but only if we have seen a 1500 file. If we haven't seen a file, then this is a probably special 1501 symbol created by md_begin which may required special handling at 1502 some point. Creating a dummy file with a dummy name is certainly 1503 wrong. */ 1504 if (cur_file_ptr == NULL 1505 && seen_at_least_1_file ()) 1506 add_file (NULL, 0, 1); 1507 obj = symbol_get_obj (symbolP); 1508 obj->ecoff_file = cur_file_ptr; 1509 obj->ecoff_symbol = NULL; 1510 obj->ecoff_extern_size = 0; 1511 } 1512 1513 void 1514 ecoff_symbol_clone_hook (symbolS *newsymP, symbolS *orgsymP) 1515 { 1516 OBJ_SYMFIELD_TYPE *n, *o; 1517 1518 n = symbol_get_obj (newsymP); 1519 o = symbol_get_obj (orgsymP); 1520 memcpy (n, o, sizeof *n); 1521 } 1522 1523 /* Add a page to a varray object. */ 1525 1526 static void 1527 add_varray_page (varray_t *vp /* varray to add page to */) 1528 { 1529 vlinks_t *new_links = allocate_vlinks (); 1530 1531 #ifdef MALLOC_CHECK 1532 if (vp->object_size > 1) 1533 new_links->datum = xcalloc (1, vp->object_size); 1534 else 1535 #endif 1536 new_links->datum = allocate_page (); 1537 1538 alloc_counts[alloc_type_varray].total_alloc++; 1539 alloc_counts[alloc_type_varray].total_pages++; 1540 1541 new_links->start_index = vp->num_allocated; 1542 vp->objects_last_page = 0; 1543 1544 if (vp->first == NULL) /* first allocation? */ 1545 vp->first = vp->last = new_links; 1546 else 1547 { /* 2nd or greater allocation */ 1548 new_links->prev = vp->last; 1549 vp->last->next = new_links; 1550 vp->last = new_links; 1551 } 1552 } 1553 1554 /* Add a string (and null pad) to one of the string tables. */ 1556 1557 static symint_t 1558 add_string (varray_t *vp, /* string obstack */ 1559 htab_t hash_tbl, /* ptr to hash table */ 1560 const char *str, /* string */ 1561 shash_t **ret_hash /* return hash pointer */) 1562 { 1563 unsigned long len = strlen (str); 1564 shash_t *hash_ptr; 1565 1566 if (len >= PAGE_USIZE) 1567 as_fatal (_("string too big (%lu bytes)"), len); 1568 1569 hash_ptr = str_hash_find (hash_tbl, str); 1570 if (hash_ptr == NULL) 1571 { 1572 if (vp->objects_last_page + len >= PAGE_USIZE) 1573 { 1574 vp->num_allocated = 1575 ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE; 1576 add_varray_page (vp); 1577 } 1578 1579 hash_ptr = allocate_shash (); 1580 hash_ptr->indx = vp->num_allocated; 1581 1582 hash_ptr->string = &vp->last->datum->byte[vp->objects_last_page]; 1583 1584 vp->objects_last_page += len + 1; 1585 vp->num_allocated += len + 1; 1586 1587 strcpy (hash_ptr->string, str); 1588 1589 if (str_hash_insert (hash_tbl, str, hash_ptr, 0) != NULL) 1590 as_fatal (_("duplicate %s"), str); 1591 } 1592 1593 if (ret_hash != NULL) 1594 *ret_hash = hash_ptr; 1595 1596 return hash_ptr->indx; 1597 } 1598 1599 /* Add debugging information for a symbol. */ 1601 1602 static localsym_t * 1603 add_ecoff_symbol (const char *str, /* symbol name */ 1604 st_t type, /* symbol type */ 1605 sc_t storage, /* storage class */ 1606 symbolS *sym_value, /* associated symbol. */ 1607 bfd_vma addend, /* addend to sym_value. */ 1608 symint_t value, /* value of symbol */ 1609 symint_t indx /* index to local/aux. syms */) 1610 { 1611 localsym_t *psym; 1612 scope_t *pscope; 1613 thead_t *ptag_head; 1614 tag_t *ptag; 1615 tag_t *ptag_next; 1616 varray_t *vp; 1617 int scope_delta = 0; 1618 shash_t *hash_ptr = NULL; 1619 1620 if (cur_file_ptr == NULL) 1621 as_fatal (_("no current file pointer")); 1622 1623 vp = &cur_file_ptr->symbols; 1624 1625 if (vp->objects_last_page == vp->objects_per_page) 1626 add_varray_page (vp); 1627 1628 psym = &vp->last->datum->sym[vp->objects_last_page++]; 1629 1630 if (str == NULL && sym_value != NULL) 1631 psym->name = S_GET_NAME (sym_value); 1632 else 1633 psym->name = str; 1634 psym->as_sym = sym_value; 1635 if (sym_value != NULL) 1636 symbol_get_obj (sym_value)->ecoff_symbol = psym; 1637 psym->addend = addend; 1638 psym->file_ptr = cur_file_ptr; 1639 psym->proc_ptr = cur_proc_ptr; 1640 psym->begin_ptr = NULL; 1641 psym->index_ptr = NULL; 1642 psym->forward_ref = NULL; 1643 psym->sym_index = -1; 1644 memset (&psym->ecoff_sym, 0, sizeof (EXTR)); 1645 psym->ecoff_sym.asym.value = value; 1646 psym->ecoff_sym.asym.st = type; 1647 psym->ecoff_sym.asym.sc = storage; 1648 psym->ecoff_sym.asym.index = indx; 1649 1650 /* If there is an associated symbol, we wait until the end of the 1651 assembly before deciding where to put the name (it may be just an 1652 external symbol). Otherwise, this is just a debugging symbol and 1653 the name should go with the current file. */ 1654 if (sym_value == NULL) 1655 psym->ecoff_sym.asym.iss = (str == NULL 1656 ? 0 1657 : add_string (&cur_file_ptr->strings, 1658 cur_file_ptr->str_hash, 1659 str, 1660 &hash_ptr)); 1661 1662 ++vp->num_allocated; 1663 1664 if (ECOFF_IS_STAB (&psym->ecoff_sym.asym)) 1665 return psym; 1666 1667 /* Save the symbol within the hash table if this is a static 1668 item, and it has a name. */ 1669 if (hash_ptr != NULL 1670 && (type == st_Global || type == st_Static || type == st_Label 1671 || type == st_Proc || type == st_StaticProc)) 1672 hash_ptr->sym_ptr = psym; 1673 1674 /* push or pop a scope if appropriate. */ 1675 switch (type) 1676 { 1677 default: 1678 break; 1679 1680 case st_File: /* beginning of file */ 1681 case st_Proc: /* procedure */ 1682 case st_StaticProc: /* static procedure */ 1683 case st_Block: /* begin scope */ 1684 pscope = allocate_scope (); 1685 pscope->prev = cur_file_ptr->cur_scope; 1686 pscope->lsym = psym; 1687 pscope->type = type; 1688 cur_file_ptr->cur_scope = pscope; 1689 1690 if (type != st_File) 1691 scope_delta = 1; 1692 1693 /* For every block type except file, struct, union, or 1694 enumeration blocks, push a level on the tag stack. We omit 1695 file types, so that tags can span file boundaries. */ 1696 if (type != st_File && storage != sc_Info) 1697 { 1698 ptag_head = allocate_thead (); 1699 ptag_head->first_tag = 0; 1700 ptag_head->prev = cur_tag_head; 1701 cur_tag_head = ptag_head; 1702 } 1703 break; 1704 1705 case st_End: 1706 pscope = cur_file_ptr->cur_scope; 1707 if (pscope == NULL) 1708 as_fatal (_("too many st_End's")); 1709 else 1710 { 1711 st_t begin_type = pscope->lsym->ecoff_sym.asym.st; 1712 1713 psym->begin_ptr = pscope->lsym; 1714 1715 if (begin_type != st_File) 1716 scope_delta = -1; 1717 1718 /* Except for file, structure, union, or enumeration end 1719 blocks remove all tags created within this scope. */ 1720 if (begin_type != st_File && storage != sc_Info) 1721 { 1722 ptag_head = cur_tag_head; 1723 cur_tag_head = ptag_head->prev; 1724 1725 for (ptag = ptag_head->first_tag; 1726 ptag != NULL; 1727 ptag = ptag_next) 1728 { 1729 if (ptag->forward_ref != NULL) 1730 add_unknown_tag (ptag); 1731 1732 ptag_next = ptag->same_block; 1733 ptag->hash_ptr->tag_ptr = ptag->same_name; 1734 free_tag (ptag); 1735 } 1736 1737 free_thead (ptag_head); 1738 } 1739 1740 cur_file_ptr->cur_scope = pscope->prev; 1741 1742 /* block begin gets next sym #. This is set when we know 1743 the symbol index value. */ 1744 1745 /* Functions push two or more aux words as follows: 1746 1st word: index+1 of the end symbol (filled in later). 1747 2nd word: type of the function (plus any aux words needed). 1748 Also, tie the external pointer back to the function begin symbol. */ 1749 if (begin_type != st_File && begin_type != st_Block) 1750 { 1751 symint_t ty; 1752 varray_t *svp = &cur_file_ptr->aux_syms; 1753 1754 pscope->lsym->ecoff_sym.asym.index = add_aux_sym_symint (0); 1755 pscope->lsym->index_ptr = 1756 &svp->last->datum->aux[svp->objects_last_page - 1]; 1757 ty = add_aux_sym_tir (&last_func_type_info, 1758 hash_no, 1759 &cur_file_ptr->thash_head[0]); 1760 (void) ty; 1761 /* This seems to be unnecessary. I'm not even sure what it is 1762 * intended to do. It's from mips-tfile. 1763 * if (last_func_sym_value != (symbolS *) NULL) 1764 * { 1765 * last_func_sym_value->ifd = cur_file_ptr->file_index; 1766 * last_func_sym_value->index = ty; 1767 * } 1768 */ 1769 } 1770 1771 free_scope (pscope); 1772 } 1773 } 1774 1775 cur_file_ptr->nested_scopes += scope_delta; 1776 1777 #ifdef ECOFF_DEBUG 1778 if (debug && type != st_File 1779 && (debug > 2 || type == st_Block || type == st_End 1780 || type == st_Proc || type == st_StaticProc)) 1781 { 1782 char *sc_str = sc_to_string (storage); 1783 char *st_str = st_to_string (type); 1784 int depth = cur_file_ptr->nested_scopes + (scope_delta < 0); 1785 1786 fprintf (stderr, 1787 "\tlsym\tv= %10ld, depth= %2d, sc= %-12s", 1788 value, depth, sc_str); 1789 1790 if (str_start && str_end_p1 - str_start > 0) 1791 fprintf (stderr, " st= %-11s name= %.*s\n", 1792 st_str, str_end_p1 - str_start, str_start); 1793 else 1794 { 1795 unsigned long len = strlen (st_str); 1796 fprintf (stderr, " st= %.*s\n", len - 1, st_str); 1797 } 1798 } 1799 #endif 1800 1801 return psym; 1802 } 1803 1804 /* Add an auxiliary symbol (passing a symint). This is actually used 1806 for integral aux types, not just symints. */ 1807 1808 static symint_t 1809 add_aux_sym_symint (symint_t aux_word /* auxiliary information word */) 1810 { 1811 varray_t *vp; 1812 aux_t *aux_ptr; 1813 1814 if (cur_file_ptr == NULL) 1815 as_fatal (_("no current file pointer")); 1816 1817 vp = &cur_file_ptr->aux_syms; 1818 1819 if (vp->objects_last_page == vp->objects_per_page) 1820 add_varray_page (vp); 1821 1822 aux_ptr = &vp->last->datum->aux[vp->objects_last_page++]; 1823 aux_ptr->type = aux_isym; 1824 aux_ptr->data.isym = aux_word; 1825 1826 return vp->num_allocated++; 1827 } 1828 1829 /* Add an auxiliary symbol (passing a file/symbol index combo). */ 1830 1831 static symint_t 1832 add_aux_sym_rndx (int file_index, symint_t sym_index) 1833 { 1834 varray_t *vp; 1835 aux_t *aux_ptr; 1836 1837 if (cur_file_ptr == NULL) 1838 as_fatal (_("no current file pointer")); 1839 1840 vp = &cur_file_ptr->aux_syms; 1841 1842 if (vp->objects_last_page == vp->objects_per_page) 1843 add_varray_page (vp); 1844 1845 aux_ptr = &vp->last->datum->aux[vp->objects_last_page++]; 1846 aux_ptr->type = aux_rndx; 1847 aux_ptr->data.rndx.rfd = file_index; 1848 aux_ptr->data.rndx.index = sym_index; 1849 1850 return vp->num_allocated++; 1851 } 1852 1853 /* Add an auxiliary symbol (passing the basic type and possibly 1855 type qualifiers). */ 1856 1857 static symint_t 1858 add_aux_sym_tir (type_info_t *t, /* current type information */ 1859 hash_state_t state, /* whether to hash type or not */ 1860 thash_t **hash_tbl /* pointer to hash table to use */) 1861 { 1862 varray_t *vp; 1863 aux_t *aux_ptr; 1864 symint_t ret; 1865 int i; 1866 AUXU aux; 1867 1868 if (cur_file_ptr == NULL) 1869 as_fatal (_("no current file pointer")); 1870 1871 vp = &cur_file_ptr->aux_syms; 1872 1873 memset (&aux, 0, sizeof (aux)); 1874 aux.ti.bt = t->basic_type; 1875 aux.ti.continued = 0; 1876 aux.ti.fBitfield = t->bitfield; 1877 1878 aux.ti.tq0 = t->type_qualifiers[0]; 1879 aux.ti.tq1 = t->type_qualifiers[1]; 1880 aux.ti.tq2 = t->type_qualifiers[2]; 1881 aux.ti.tq3 = t->type_qualifiers[3]; 1882 aux.ti.tq4 = t->type_qualifiers[4]; 1883 aux.ti.tq5 = t->type_qualifiers[5]; 1884 1885 /* For anything that adds additional information, we must not hash, 1886 so check here, and reset our state. */ 1887 1888 if (state != hash_no 1889 && (t->type_qualifiers[0] == tq_Array 1890 || t->type_qualifiers[1] == tq_Array 1891 || t->type_qualifiers[2] == tq_Array 1892 || t->type_qualifiers[3] == tq_Array 1893 || t->type_qualifiers[4] == tq_Array 1894 || t->type_qualifiers[5] == tq_Array 1895 || t->basic_type == bt_Struct 1896 || t->basic_type == bt_Union 1897 || t->basic_type == bt_Enum 1898 || t->bitfield 1899 || t->num_dims > 0)) 1900 state = hash_no; 1901 1902 /* See if we can hash this type, and save some space, but some types 1903 can't be hashed (because they contain arrays or continuations), 1904 and others can be put into the hash list, but cannot use existing 1905 types because other aux entries precede this one. */ 1906 1907 if (state != hash_no) 1908 { 1909 thash_t *hash_ptr; 1910 symint_t hi; 1911 1912 hi = aux.isym & ((1 << HASHBITS) - 1); 1913 hi %= THASH_SIZE; 1914 1915 for (hash_ptr = hash_tbl[hi]; 1916 hash_ptr; 1917 hash_ptr = hash_ptr->next) 1918 { 1919 if (aux.isym == hash_ptr->type.isym) 1920 break; 1921 } 1922 1923 if (hash_ptr != NULL && state == hash_yes) 1924 return hash_ptr->indx; 1925 1926 if (hash_ptr == NULL) 1927 { 1928 hash_ptr = allocate_thash (); 1929 hash_ptr->next = hash_tbl[hi]; 1930 hash_ptr->type = aux; 1931 hash_ptr->indx = vp->num_allocated; 1932 hash_tbl[hi] = hash_ptr; 1933 } 1934 } 1935 1936 /* Everything is set up, add the aux symbol. */ 1937 if (vp->objects_last_page == vp->objects_per_page) 1938 add_varray_page (vp); 1939 1940 aux_ptr = &vp->last->datum->aux[vp->objects_last_page++]; 1941 aux_ptr->type = aux_tir; 1942 aux_ptr->data = aux; 1943 1944 ret = vp->num_allocated++; 1945 1946 /* Add bitfield length if it exists. 1947 1948 NOTE: Mips documentation claims bitfield goes at the end of the 1949 AUX record, but the DECstation compiler emits it here. 1950 (This would only make a difference for enum bitfields.) 1951 1952 Also note: We use the last size given since gcc may emit 2 1953 for an enum bitfield. */ 1954 1955 if (t->bitfield) 1956 (void) add_aux_sym_symint (t->sizes[t->num_sizes - 1]); 1957 1958 /* Add tag information if needed. Structure, union, and enum 1959 references add 2 aux symbols: a [file index, symbol index] 1960 pointer to the structure type, and the current file index. */ 1961 1962 if (t->basic_type == bt_Struct 1963 || t->basic_type == bt_Union 1964 || t->basic_type == bt_Enum) 1965 { 1966 symint_t file_index = t->tag_ptr->ifd; 1967 localsym_t *sym = t->tag_ptr->sym; 1968 forward_t *forward_ref = allocate_forward (); 1969 1970 if (sym != NULL) 1971 { 1972 forward_ref->next = sym->forward_ref; 1973 sym->forward_ref = forward_ref; 1974 } 1975 else 1976 { 1977 forward_ref->next = t->tag_ptr->forward_ref; 1978 t->tag_ptr->forward_ref = forward_ref; 1979 } 1980 1981 (void) add_aux_sym_rndx (ST_RFDESCAPE, indexNil); 1982 forward_ref->index_ptr 1983 = &vp->last->datum->aux[vp->objects_last_page - 1]; 1984 1985 (void) add_aux_sym_symint (file_index); 1986 forward_ref->ifd_ptr 1987 = &vp->last->datum->aux[vp->objects_last_page - 1]; 1988 } 1989 1990 /* Add information about array bounds if they exist. */ 1991 for (i = 0; i < t->num_dims; i++) 1992 { 1993 (void) add_aux_sym_rndx (ST_RFDESCAPE, 1994 cur_file_ptr->int_type); 1995 1996 (void) add_aux_sym_symint (cur_file_ptr->file_index); /* file index*/ 1997 (void) add_aux_sym_symint (0); /* low bound */ 1998 (void) add_aux_sym_symint (t->dimensions[i] - 1); /* high bound*/ 1999 (void) add_aux_sym_symint ((t->dimensions[i] == 0) /* stride */ 2000 ? 0 2001 : (t->sizes[i] * 8) / t->dimensions[i]); 2002 }; 2003 2004 /* NOTE: Mips documentation claims that the bitfield width goes here. 2005 But it needs to be emitted earlier. */ 2006 2007 return ret; 2008 } 2009 2010 /* Add a tag to the tag table (unless it already exists). */ 2012 2013 static tag_t * 2014 get_tag (const char *tag, /* tag name */ 2015 localsym_t *sym, /* tag start block */ 2016 bt_t basic_type /* bt_Struct, bt_Union, or bt_Enum */) 2017 { 2018 shash_t *hash_ptr; 2019 tag_t *tag_ptr; 2020 2021 if (cur_file_ptr == NULL) 2022 as_fatal (_("no current file pointer")); 2023 2024 hash_ptr = str_hash_find (tag_hash, tag); 2025 2026 if (hash_ptr != NULL 2027 && hash_ptr->tag_ptr != NULL) 2028 { 2029 tag_ptr = hash_ptr->tag_ptr; 2030 if (sym != NULL) 2031 { 2032 tag_ptr->basic_type = basic_type; 2033 tag_ptr->ifd = cur_file_ptr->file_index; 2034 tag_ptr->sym = sym; 2035 } 2036 return tag_ptr; 2037 } 2038 2039 if (hash_ptr == NULL) 2040 { 2041 char *perm; 2042 2043 perm = xstrdup (tag); 2044 hash_ptr = allocate_shash (); 2045 str_hash_insert (tag_hash, perm, hash_ptr, 0); 2046 hash_ptr->string = perm; 2047 } 2048 2049 tag_ptr = allocate_tag (); 2050 tag_ptr->forward_ref = NULL; 2051 tag_ptr->hash_ptr = hash_ptr; 2052 tag_ptr->same_name = hash_ptr->tag_ptr; 2053 tag_ptr->basic_type = basic_type; 2054 tag_ptr->sym = sym; 2055 tag_ptr->ifd = (sym == NULL 2056 ? (symint_t) -1 2057 : cur_file_ptr->file_index); 2058 tag_ptr->same_block = cur_tag_head->first_tag; 2059 2060 cur_tag_head->first_tag = tag_ptr; 2061 hash_ptr->tag_ptr = tag_ptr; 2062 2063 return tag_ptr; 2064 } 2065 2066 /* Add an unknown {struct, union, enum} tag. */ 2068 2069 static void 2070 add_unknown_tag (tag_t *ptag /* pointer to tag information */) 2071 { 2072 shash_t *hash_ptr = ptag->hash_ptr; 2073 char *name = hash_ptr->string; 2074 localsym_t *sym; 2075 forward_t **pf; 2076 2077 #ifdef ECOFF_DEBUG 2078 if (debug > 1) 2079 { 2080 char *agg_type = "{unknown aggregate type}"; 2081 switch (ptag->basic_type) 2082 { 2083 case bt_Struct: agg_type = "struct"; break; 2084 case bt_Union: agg_type = "union"; break; 2085 case bt_Enum: agg_type = "enum"; break; 2086 default: break; 2087 } 2088 2089 fprintf (stderr, "unknown %s %.*s found\n", agg_type, 2090 hash_ptr->len, name_start); 2091 } 2092 #endif 2093 2094 sym = add_ecoff_symbol (name, st_Block, sc_Info, NULL, 0, 0, 0); 2095 2096 (void) add_ecoff_symbol (name, st_End, sc_Info, NULL, 0, 0, 0); 2097 2098 for (pf = &sym->forward_ref; *pf != NULL; pf = &(*pf)->next) 2099 ; 2100 *pf = ptag->forward_ref; 2101 } 2102 2103 /* Add a procedure to the current file's list of procedures, and record 2105 this is the current procedure. If AENT, then only set the requested 2106 symbol's function type. */ 2107 2108 static void 2109 add_procedure (char *func /* func name */, int aent) 2110 { 2111 varray_t *vp; 2112 proc_t *new_proc_ptr; 2113 symbolS *sym; 2114 2115 #ifdef ECOFF_DEBUG 2116 if (debug) 2117 fputc ('\n', stderr); 2118 #endif 2119 2120 /* Set the BSF_FUNCTION flag for the symbol. */ 2121 sym = symbol_find_or_make (func); 2122 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION; 2123 2124 if (aent) 2125 return; 2126 2127 if (cur_file_ptr == NULL) 2128 as_fatal (_("no current file pointer")); 2129 2130 vp = &cur_file_ptr->procs; 2131 2132 if (vp->objects_last_page == vp->objects_per_page) 2133 add_varray_page (vp); 2134 2135 cur_proc_ptr = new_proc_ptr = &vp->last->datum->proc[vp->objects_last_page++]; 2136 2137 if (first_proc_ptr == NULL) 2138 first_proc_ptr = new_proc_ptr; 2139 2140 vp->num_allocated++; 2141 2142 new_proc_ptr->pdr.isym = -1; 2143 new_proc_ptr->pdr.iline = -1; 2144 new_proc_ptr->pdr.lnLow = -1; 2145 new_proc_ptr->pdr.lnHigh = -1; 2146 2147 /* Push the start of the function. */ 2148 new_proc_ptr->sym = add_ecoff_symbol (NULL, st_Proc, sc_Text, sym, 0, 0, 0); 2149 2150 ++proc_cnt; 2151 2152 /* Fill in the linenos preceding the .ent, if any. */ 2153 if (noproc_lineno != NULL) 2154 { 2155 lineno_list_t *l; 2156 2157 for (l = noproc_lineno; l != NULL; l = l->next) 2158 l->proc = new_proc_ptr; 2159 *last_lineno_ptr = noproc_lineno; 2160 while (*last_lineno_ptr != NULL) 2161 { 2162 last_lineno = *last_lineno_ptr; 2163 last_lineno_ptr = &last_lineno->next; 2164 } 2165 noproc_lineno = NULL; 2166 } 2167 } 2168 2169 symbolS * 2170 ecoff_get_cur_proc_sym (void) 2171 { 2172 return (cur_proc_ptr ? cur_proc_ptr->sym->as_sym : NULL); 2173 } 2174 2175 /* Add a new filename, and set up all of the file relative 2177 virtual arrays (strings, symbols, aux syms, etc.). Record 2178 where the current file structure lives. */ 2179 2180 static void 2181 add_file (const char *file_name, int indx ATTRIBUTE_UNUSED, int fake) 2182 { 2183 int first_ch; 2184 efdr_t *fil_ptr; 2185 2186 #ifdef ECOFF_DEBUG 2187 if (debug) 2188 fprintf (stderr, "\tfile\t%.*s\n", len, file_start); 2189 #endif 2190 2191 /* If the file name is NULL, then no .file symbol appeared, and we 2192 want to use the actual file name. */ 2193 if (file_name == NULL) 2194 { 2195 if (first_file != NULL) 2196 as_fatal (_("fake .file after real one")); 2197 file_name = as_where (NULL); 2198 2199 /* Automatically generate ECOFF debugging information, since I 2200 think that's what other ECOFF assemblers do. We don't do 2201 this if we see a .file directive with a string, since that 2202 implies that some sort of debugging information is being 2203 provided. */ 2204 if (! symbol_table_frozen && debug_type == DEBUG_UNSPECIFIED) 2205 debug_type = DEBUG_ECOFF; 2206 } 2207 else if (debug_type == DEBUG_UNSPECIFIED) 2208 debug_type = DEBUG_NONE; 2209 2210 #ifndef NO_LISTING 2211 if (listing) 2212 listing_source_file (file_name); 2213 #endif 2214 2215 current_stabs_filename = file_name; 2216 2217 /* If we're creating stabs, then we don't actually make a new FDR. 2218 Instead, we just create a stabs symbol. */ 2219 if (stabs_seen) 2220 { 2221 (void) add_ecoff_symbol (file_name, st_Nil, sc_Nil, 2222 symbol_new (FAKE_LABEL_NAME, now_seg, 2223 frag_now, frag_now_fix ()), 2224 0, 0, ECOFF_MARK_STAB (N_SOL)); 2225 return; 2226 } 2227 2228 first_ch = *file_name; 2229 2230 /* FIXME: We can't safely merge files which have line number 2231 information (fMerge will be zero in this case). Otherwise, we 2232 get incorrect line number debugging info. See for instance 2233 ecoff_build_lineno, which will end up setting all file->fdr.* 2234 fields multiple times, resulting in incorrect debug info. In 2235 order to make this work right, all line number and symbol info 2236 for the same source file has to be adjacent in the object file, 2237 so that a single file descriptor can be used to point to them. 2238 This would require maintaining file specific lists of line 2239 numbers and symbols for each file, so that they can be merged 2240 together (or output together) when two .file pseudo-ops are 2241 merged into one file descriptor. */ 2242 2243 /* See if the file has already been created. */ 2244 for (fil_ptr = first_file; 2245 fil_ptr != NULL; 2246 fil_ptr = fil_ptr->next_file) 2247 { 2248 if (first_ch == fil_ptr->name[0] 2249 && filename_cmp (file_name, fil_ptr->name) == 0 2250 && fil_ptr->fdr.fMerge) 2251 { 2252 cur_file_ptr = fil_ptr; 2253 if (! fake) 2254 cur_file_ptr->fake = 0; 2255 break; 2256 } 2257 } 2258 2259 /* If this is a new file, create it. */ 2260 if (fil_ptr == NULL) 2261 { 2262 if (file_desc.objects_last_page == file_desc.objects_per_page) 2263 add_varray_page (&file_desc); 2264 2265 fil_ptr = cur_file_ptr = 2266 &file_desc.last->datum->file[file_desc.objects_last_page++]; 2267 *fil_ptr = init_file; 2268 2269 fil_ptr->file_index = current_file_idx++; 2270 ++file_desc.num_allocated; 2271 2272 fil_ptr->fake = fake; 2273 2274 /* Allocate the string hash table. */ 2275 fil_ptr->str_hash = str_htab_create (); 2276 2277 /* Make sure 0 byte in string table is null */ 2278 add_string (&fil_ptr->strings, fil_ptr->str_hash, "", NULL); 2279 2280 if (strlen (file_name) > PAGE_USIZE - 2) 2281 as_fatal (_("filename goes over one page boundary")); 2282 2283 /* Push the start of the filename. We assume that the filename 2284 will be stored at string offset 1. */ 2285 (void) add_ecoff_symbol (file_name, st_File, sc_Text, NULL, 0, 0, 0); 2286 fil_ptr->fdr.rss = 1; 2287 fil_ptr->name = &fil_ptr->strings.last->datum->byte[1]; 2288 2289 /* Update the linked list of file descriptors. */ 2290 *last_file_ptr = fil_ptr; 2291 last_file_ptr = &fil_ptr->next_file; 2292 2293 /* Add void & int types to the file (void should be first to catch 2294 errant 0's within the index fields). */ 2295 fil_ptr->void_type = add_aux_sym_tir (&void_type_info, 2296 hash_yes, 2297 &cur_file_ptr->thash_head[0]); 2298 2299 fil_ptr->int_type = add_aux_sym_tir (&int_type_info, 2300 hash_yes, 2301 &cur_file_ptr->thash_head[0]); 2302 } 2303 } 2304 2305 /* This function is called when the assembler notices a preprocessor 2306 directive switching to a new file. This will not happen in 2307 compiler output, only in hand coded assembler. */ 2308 2309 void 2310 ecoff_new_file (const char *name) 2311 { 2312 if (cur_file_ptr != NULL && filename_cmp (cur_file_ptr->name, name) == 0) 2313 return; 2314 add_file (name, 0, 0); 2315 2316 /* This is a hand coded assembler file, so automatically turn on 2317 debugging information. */ 2318 if (debug_type == DEBUG_UNSPECIFIED) 2319 debug_type = DEBUG_ECOFF; 2320 } 2321 2322 #ifdef ECOFF_DEBUG 2324 2325 /* Convert storage class to string. */ 2326 2327 static char * 2328 sc_to_string (storage_class) 2329 sc_t storage_class; 2330 { 2331 switch (storage_class) 2332 { 2333 case sc_Nil: return "Nil,"; 2334 case sc_Text: return "Text,"; 2335 case sc_Data: return "Data,"; 2336 case sc_Bss: return "Bss,"; 2337 case sc_Register: return "Register,"; 2338 case sc_Abs: return "Abs,"; 2339 case sc_Undefined: return "Undefined,"; 2340 case sc_CdbLocal: return "CdbLocal,"; 2341 case sc_Bits: return "Bits,"; 2342 case sc_CdbSystem: return "CdbSystem,"; 2343 case sc_RegImage: return "RegImage,"; 2344 case sc_Info: return "Info,"; 2345 case sc_UserStruct: return "UserStruct,"; 2346 case sc_SData: return "SData,"; 2347 case sc_SBss: return "SBss,"; 2348 case sc_RData: return "RData,"; 2349 case sc_Var: return "Var,"; 2350 case sc_Common: return "Common,"; 2351 case sc_SCommon: return "SCommon,"; 2352 case sc_VarRegister: return "VarRegister,"; 2353 case sc_Variant: return "Variant,"; 2354 case sc_SUndefined: return "SUndefined,"; 2355 case sc_Init: return "Init,"; 2356 case sc_Max: return "Max,"; 2357 } 2358 2359 return "???,"; 2360 } 2361 2362 #endif /* DEBUG */ 2363 2364 #ifdef ECOFF_DEBUG 2366 2367 /* Convert symbol type to string. */ 2368 2369 static char * 2370 st_to_string (symbol_type) 2371 st_t symbol_type; 2372 { 2373 switch (symbol_type) 2374 { 2375 case st_Nil: return "Nil,"; 2376 case st_Global: return "Global,"; 2377 case st_Static: return "Static,"; 2378 case st_Param: return "Param,"; 2379 case st_Local: return "Local,"; 2380 case st_Label: return "Label,"; 2381 case st_Proc: return "Proc,"; 2382 case st_Block: return "Block,"; 2383 case st_End: return "End,"; 2384 case st_Member: return "Member,"; 2385 case st_Typedef: return "Typedef,"; 2386 case st_File: return "File,"; 2387 case st_RegReloc: return "RegReloc,"; 2388 case st_Forward: return "Forward,"; 2389 case st_StaticProc: return "StaticProc,"; 2390 case st_Constant: return "Constant,"; 2391 case st_Str: return "String,"; 2392 case st_Number: return "Number,"; 2393 case st_Expr: return "Expr,"; 2394 case st_Type: return "Type,"; 2395 case st_Max: return "Max,"; 2396 } 2397 2398 return "???,"; 2399 } 2400 2401 #endif /* DEBUG */ 2402 2403 /* Parse .begin directives which have a label as the first argument 2405 which gives the location of the start of the block. */ 2406 2407 void 2408 ecoff_directive_begin (int ignore ATTRIBUTE_UNUSED) 2409 { 2410 char *name; 2411 char name_end; 2412 2413 if (cur_file_ptr == NULL) 2414 { 2415 as_warn (_(".begin directive without a preceding .file directive")); 2416 demand_empty_rest_of_line (); 2417 return; 2418 } 2419 2420 if (cur_proc_ptr == NULL) 2421 { 2422 as_warn (_(".begin directive without a preceding .ent directive")); 2423 demand_empty_rest_of_line (); 2424 return; 2425 } 2426 2427 name_end = get_symbol_name (&name); 2428 2429 (void) add_ecoff_symbol (NULL, st_Block, sc_Text, 2430 symbol_find_or_make (name), 0, 0, 0); 2431 2432 (void) restore_line_pointer (name_end); 2433 2434 /* The line number follows, but we don't use it. */ 2435 (void) get_absolute_expression (); 2436 demand_empty_rest_of_line (); 2437 } 2438 2439 /* Parse .bend directives which have a label as the first argument 2441 which gives the location of the end of the block. */ 2442 2443 void 2444 ecoff_directive_bend (int ignore ATTRIBUTE_UNUSED) 2445 { 2446 char *name; 2447 char name_end; 2448 symbolS *endsym; 2449 2450 if (cur_file_ptr == NULL) 2451 { 2452 as_warn (_(".bend directive without a preceding .file directive")); 2453 demand_empty_rest_of_line (); 2454 return; 2455 } 2456 2457 if (cur_proc_ptr == NULL) 2458 { 2459 as_warn (_(".bend directive without a preceding .ent directive")); 2460 demand_empty_rest_of_line (); 2461 return; 2462 } 2463 2464 name_end = get_symbol_name (&name); 2465 2466 /* The value is the distance between the .bend directive and the 2467 corresponding symbol. We fill in the offset when we write out 2468 the symbol. */ 2469 endsym = symbol_find (name); 2470 if (endsym == NULL) 2471 as_warn (_(".bend directive names unknown symbol")); 2472 else 2473 (void) add_ecoff_symbol (NULL, st_End, sc_Text, endsym, 0, 0, 0); 2474 2475 restore_line_pointer (name_end); 2476 2477 /* The line number follows, but we don't use it. */ 2478 (void) get_absolute_expression (); 2479 demand_empty_rest_of_line (); 2480 } 2481 2482 /* COFF debugging information is provided as a series of directives 2484 (.def, .scl, etc.). We build up information as we read the 2485 directives in the following static variables, and file it away when 2486 we reach the .endef directive. */ 2487 static char *coff_sym_name; 2488 static type_info_t coff_type; 2489 static sc_t coff_storage_class; 2490 static st_t coff_symbol_typ; 2491 static int coff_is_function; 2492 static char *coff_tag; 2493 static valueT coff_value; 2494 static symbolS *coff_sym_value; 2495 static bfd_vma coff_sym_addend; 2496 static int coff_inside_enumeration; 2497 2498 /* Handle a .def directive: start defining a symbol. */ 2499 2500 void 2501 ecoff_directive_def (int ignore ATTRIBUTE_UNUSED) 2502 { 2503 char *name; 2504 char name_end; 2505 2506 ecoff_debugging_seen = 1; 2507 2508 SKIP_WHITESPACE (); 2509 2510 name_end = get_symbol_name (&name); 2511 2512 if (coff_sym_name != NULL) 2513 as_warn (_(".def pseudo-op used inside of .def/.endef; ignored")); 2514 else if (*name == '\0') 2515 as_warn (_("empty symbol name in .def; ignored")); 2516 else 2517 { 2518 free (coff_sym_name); 2519 free (coff_tag); 2520 2521 coff_sym_name = xstrdup (name); 2522 coff_type = type_info_init; 2523 coff_storage_class = sc_Nil; 2524 coff_symbol_typ = st_Nil; 2525 coff_is_function = 0; 2526 coff_tag = NULL; 2527 coff_value = 0; 2528 coff_sym_value = NULL; 2529 coff_sym_addend = 0; 2530 } 2531 2532 restore_line_pointer (name_end); 2533 2534 demand_empty_rest_of_line (); 2535 } 2536 2537 /* Handle a .dim directive, used to give dimensions for an array. The 2538 arguments are comma separated numbers. mips-tfile assumes that 2539 there will not be more than 6 dimensions, and gdb won't read any 2540 more than that anyhow, so I will also make that assumption. */ 2541 2542 void 2543 ecoff_directive_dim (int ignore ATTRIBUTE_UNUSED) 2544 { 2545 int dimens[N_TQ]; 2546 int i; 2547 2548 if (coff_sym_name == NULL) 2549 { 2550 as_warn (_(".dim pseudo-op used outside of .def/.endef; ignored")); 2551 demand_empty_rest_of_line (); 2552 return; 2553 } 2554 2555 for (i = 0; i < N_TQ; i++) 2556 { 2557 SKIP_WHITESPACE (); 2558 dimens[i] = get_absolute_expression (); 2559 if (*input_line_pointer == ',') 2560 ++input_line_pointer; 2561 else 2562 { 2563 if (*input_line_pointer != '\n' 2564 && *input_line_pointer != ';') 2565 as_warn (_("badly formed .dim directive")); 2566 break; 2567 } 2568 } 2569 2570 if (i == N_TQ) 2571 --i; 2572 2573 /* The dimensions are stored away in reverse order. */ 2574 for (; i >= 0; i--) 2575 { 2576 if (coff_type.num_dims >= N_TQ) 2577 { 2578 as_warn (_("too many .dim entries")); 2579 break; 2580 } 2581 coff_type.dimensions[coff_type.num_dims] = dimens[i]; 2582 ++coff_type.num_dims; 2583 } 2584 2585 demand_empty_rest_of_line (); 2586 } 2587 2588 /* Handle a .scl directive, which sets the COFF storage class of the 2589 symbol. */ 2590 2591 void 2592 ecoff_directive_scl (int ignore ATTRIBUTE_UNUSED) 2593 { 2594 long val; 2595 2596 if (coff_sym_name == NULL) 2597 { 2598 as_warn (_(".scl pseudo-op used outside of .def/.endef; ignored")); 2599 demand_empty_rest_of_line (); 2600 return; 2601 } 2602 2603 val = get_absolute_expression (); 2604 2605 coff_symbol_typ = map_coff_sym_type[val]; 2606 coff_storage_class = map_coff_storage[val]; 2607 2608 demand_empty_rest_of_line (); 2609 } 2610 2611 /* Handle a .size directive. For some reason mips-tfile.c thinks that 2612 .size can have multiple arguments. We humor it, although gcc will 2613 never generate more than one argument. */ 2614 2615 void 2616 ecoff_directive_size (int ignore ATTRIBUTE_UNUSED) 2617 { 2618 int sizes[N_TQ]; 2619 int i; 2620 2621 if (coff_sym_name == NULL) 2622 { 2623 as_warn (_(".size pseudo-op used outside of .def/.endef; ignored")); 2624 demand_empty_rest_of_line (); 2625 return; 2626 } 2627 2628 for (i = 0; i < N_TQ; i++) 2629 { 2630 SKIP_WHITESPACE (); 2631 sizes[i] = get_absolute_expression (); 2632 if (*input_line_pointer == ',') 2633 ++input_line_pointer; 2634 else 2635 { 2636 if (*input_line_pointer != '\n' 2637 && *input_line_pointer != ';') 2638 as_warn (_("badly formed .size directive")); 2639 break; 2640 } 2641 } 2642 2643 if (i == N_TQ) 2644 --i; 2645 2646 /* The sizes are stored away in reverse order. */ 2647 for (; i >= 0; i--) 2648 { 2649 if (coff_type.num_sizes >= N_TQ) 2650 { 2651 as_warn (_("too many .size entries")); 2652 break; 2653 } 2654 coff_type.sizes[coff_type.num_sizes] = sizes[i]; 2655 ++coff_type.num_sizes; 2656 } 2657 2658 demand_empty_rest_of_line (); 2659 } 2660 2661 /* Handle the .type directive, which gives the COFF type of the 2662 symbol. */ 2663 2664 void 2665 ecoff_directive_type (int ignore ATTRIBUTE_UNUSED) 2666 { 2667 long val; 2668 tq_t *tq_ptr; 2669 tq_t *tq_shft; 2670 2671 if (coff_sym_name == NULL) 2672 { 2673 as_warn (_(".type pseudo-op used outside of .def/.endef; ignored")); 2674 demand_empty_rest_of_line (); 2675 return; 2676 } 2677 2678 val = get_absolute_expression (); 2679 2680 coff_type.orig_type = BTYPE (val); 2681 coff_type.basic_type = map_coff_types[coff_type.orig_type]; 2682 2683 tq_ptr = &coff_type.type_qualifiers[N_TQ]; 2684 while (val & ~N_BTMASK) 2685 { 2686 if (tq_ptr == &coff_type.type_qualifiers[0]) 2687 { 2688 /* FIXME: We could handle this by setting the continued bit. 2689 There would still be a limit: the .type argument can not 2690 be infinite. */ 2691 as_warn (_("the type of %s is too complex; it will be simplified"), 2692 coff_sym_name); 2693 break; 2694 } 2695 if (ISPTR (val)) 2696 *--tq_ptr = tq_Ptr; 2697 else if (ISFCN (val)) 2698 *--tq_ptr = tq_Proc; 2699 else if (ISARY (val)) 2700 *--tq_ptr = tq_Array; 2701 else 2702 as_fatal (_("Unrecognized .type argument")); 2703 2704 val = DECREF (val); 2705 } 2706 2707 tq_shft = &coff_type.type_qualifiers[0]; 2708 while (tq_ptr != &coff_type.type_qualifiers[N_TQ]) 2709 *tq_shft++ = *tq_ptr++; 2710 2711 if (tq_shft != &coff_type.type_qualifiers[0] && tq_shft[-1] == tq_Proc) 2712 { 2713 /* If this is a function, ignore it, so that we don't get two 2714 entries (one from the .ent, and one for the .def that 2715 precedes it). Save the type information so that the end 2716 block can properly add it after the begin block index. For 2717 MIPS knows what reason, we must strip off the function type 2718 at this point. */ 2719 coff_is_function = 1; 2720 tq_shft[-1] = tq_Nil; 2721 } 2722 2723 while (tq_shft != &coff_type.type_qualifiers[N_TQ]) 2724 *tq_shft++ = tq_Nil; 2725 2726 demand_empty_rest_of_line (); 2727 } 2728 2729 /* Handle the .tag directive, which gives the name of a structure, 2730 union or enum. */ 2731 2732 void 2733 ecoff_directive_tag (int ignore ATTRIBUTE_UNUSED) 2734 { 2735 char *name; 2736 char name_end; 2737 2738 if (coff_sym_name == NULL) 2739 { 2740 as_warn (_(".tag pseudo-op used outside of .def/.endef; ignored")); 2741 demand_empty_rest_of_line (); 2742 return; 2743 } 2744 2745 name_end = get_symbol_name (&name); 2746 2747 coff_tag = xstrdup (name); 2748 2749 (void) restore_line_pointer (name_end); 2750 2751 demand_empty_rest_of_line (); 2752 } 2753 2754 /* Handle the .val directive, which gives the value of the symbol. It 2755 may be the name of a static or global symbol. */ 2756 2757 void 2758 ecoff_directive_val (int ignore ATTRIBUTE_UNUSED) 2759 { 2760 expressionS exp; 2761 2762 if (coff_sym_name == NULL) 2763 { 2764 as_warn (_(".val pseudo-op used outside of .def/.endef; ignored")); 2765 demand_empty_rest_of_line (); 2766 return; 2767 } 2768 2769 expression (&exp); 2770 if (exp.X_op != O_constant && exp.X_op != O_symbol) 2771 { 2772 as_bad (_(".val expression is too complex")); 2773 demand_empty_rest_of_line (); 2774 return; 2775 } 2776 2777 if (exp.X_op == O_constant) 2778 coff_value = exp.X_add_number; 2779 else 2780 { 2781 coff_sym_value = exp.X_add_symbol; 2782 coff_sym_addend = exp.X_add_number; 2783 } 2784 2785 demand_empty_rest_of_line (); 2786 } 2787 2788 /* Handle the .endef directive, which terminates processing of COFF 2789 debugging information for a symbol. */ 2790 2791 void 2792 ecoff_directive_endef (int ignore ATTRIBUTE_UNUSED) 2793 { 2794 char *name; 2795 symint_t indx; 2796 localsym_t *sym; 2797 2798 demand_empty_rest_of_line (); 2799 2800 if (coff_sym_name == NULL) 2801 { 2802 as_warn (_(".endef pseudo-op used before .def; ignored")); 2803 return; 2804 } 2805 2806 name = coff_sym_name; 2807 coff_sym_name = NULL; 2808 2809 /* If the symbol is a static or external, we have already gotten the 2810 appropriate type and class, so make sure we don't override those 2811 values. This is needed because there are some type and classes 2812 that are not in COFF, such as short data, etc. */ 2813 if (coff_sym_value != NULL) 2814 { 2815 coff_symbol_typ = st_Nil; 2816 coff_storage_class = sc_Nil; 2817 } 2818 2819 coff_type.extra_sizes = coff_tag != NULL; 2820 if (coff_type.num_dims > 0) 2821 { 2822 int diff = coff_type.num_dims - coff_type.num_sizes; 2823 int i = coff_type.num_dims - 1; 2824 int j; 2825 2826 if (coff_type.num_sizes != 1 || diff < 0) 2827 { 2828 as_warn (_("bad COFF debugging information")); 2829 return; 2830 } 2831 2832 /* If this is an array, make sure the same number of dimensions 2833 and sizes were passed, creating extra sizes for multiply 2834 dimensioned arrays if not passed. */ 2835 coff_type.extra_sizes = 0; 2836 if (diff) 2837 { 2838 j = (sizeof (coff_type.sizes) / sizeof (coff_type.sizes[0])) - 1; 2839 while (j >= 0) 2840 { 2841 coff_type.sizes[j] = (((j - diff) >= 0) 2842 ? coff_type.sizes[j - diff] 2843 : 0); 2844 j--; 2845 } 2846 2847 coff_type.num_sizes = i + 1; 2848 for (i--; i >= 0; i--) 2849 coff_type.sizes[i] = (coff_type.dimensions[i + 1] == 0 2850 ? 0 2851 : (coff_type.sizes[i + 1] 2852 / coff_type.dimensions[i + 1])); 2853 } 2854 } 2855 else if (coff_symbol_typ == st_Member 2856 && coff_type.num_sizes - coff_type.extra_sizes == 1) 2857 { 2858 /* Is this a bitfield? This is indicated by a structure member 2859 having a size field that isn't an array. */ 2860 coff_type.bitfield = 1; 2861 } 2862 2863 /* Except for enumeration members & begin/ending of scopes, put the 2864 type word in the aux. symbol table. */ 2865 if (coff_symbol_typ == st_Block || coff_symbol_typ == st_End) 2866 indx = 0; 2867 else if (coff_inside_enumeration) 2868 indx = cur_file_ptr->void_type; 2869 else 2870 { 2871 if (coff_type.basic_type == bt_Struct 2872 || coff_type.basic_type == bt_Union 2873 || coff_type.basic_type == bt_Enum) 2874 { 2875 if (coff_tag == NULL) 2876 { 2877 as_warn (_("no tag specified for %s"), name); 2878 return; 2879 } 2880 2881 coff_type.tag_ptr = get_tag (coff_tag, NULL, coff_type.basic_type); 2882 } 2883 2884 if (coff_is_function) 2885 { 2886 last_func_type_info = coff_type; 2887 last_func_sym_value = coff_sym_value; 2888 return; 2889 } 2890 2891 indx = add_aux_sym_tir (&coff_type, 2892 hash_yes, 2893 &cur_file_ptr->thash_head[0]); 2894 } 2895 2896 /* Do any last minute adjustments that are necessary. */ 2897 switch (coff_symbol_typ) 2898 { 2899 default: 2900 break; 2901 2902 /* For the beginning of structs, unions, and enumerations, the 2903 size info needs to be passed in the value field. */ 2904 case st_Block: 2905 if (coff_type.num_sizes - coff_type.num_dims - coff_type.extra_sizes 2906 != 1) 2907 { 2908 as_warn (_("bad COFF debugging information")); 2909 return; 2910 } 2911 else 2912 coff_value = coff_type.sizes[0]; 2913 2914 coff_inside_enumeration = (coff_type.orig_type == T_ENUM); 2915 break; 2916 2917 /* For the end of structs, unions, and enumerations, omit the 2918 name which is always ".eos". This needs to be done last, so 2919 that any error reporting above gives the correct name. */ 2920 case st_End: 2921 free (name); 2922 name = NULL; 2923 coff_value = 0; 2924 coff_inside_enumeration = 0; 2925 break; 2926 2927 /* Members of structures and unions that aren't bitfields, need 2928 to adjust the value from a byte offset to a bit offset. 2929 Members of enumerations do not have the value adjusted, and 2930 can be distinguished by indx == indexNil. For enumerations, 2931 update the maximum enumeration value. */ 2932 case st_Member: 2933 if (! coff_type.bitfield && ! coff_inside_enumeration) 2934 coff_value *= 8; 2935 2936 break; 2937 } 2938 2939 /* Add the symbol. */ 2940 sym = add_ecoff_symbol (name, coff_symbol_typ, coff_storage_class, 2941 coff_sym_value, coff_sym_addend, coff_value, indx); 2942 2943 /* deal with struct, union, and enum tags. */ 2944 if (coff_symbol_typ == st_Block) 2945 { 2946 /* Create or update the tag information. */ 2947 tag_t *tag_ptr = get_tag (name, sym, coff_type.basic_type); 2948 forward_t **pf; 2949 2950 /* Remember any forward references. */ 2951 for (pf = &sym->forward_ref; 2952 *pf != NULL; 2953 pf = &(*pf)->next) 2954 ; 2955 *pf = tag_ptr->forward_ref; 2956 tag_ptr->forward_ref = NULL; 2957 } 2958 } 2959 2960 /* Parse .end directives. */ 2962 2963 void 2964 ecoff_directive_end (int ignore ATTRIBUTE_UNUSED) 2965 { 2966 char *name; 2967 char name_end; 2968 symbolS *ent; 2969 2970 if (cur_file_ptr == NULL) 2971 { 2972 as_warn (_(".end directive without a preceding .file directive")); 2973 demand_empty_rest_of_line (); 2974 return; 2975 } 2976 2977 if (cur_proc_ptr == NULL) 2978 { 2979 as_warn (_(".end directive without a preceding .ent directive")); 2980 demand_empty_rest_of_line (); 2981 return; 2982 } 2983 2984 name_end = get_symbol_name (&name); 2985 2986 if (name == input_line_pointer) 2987 { 2988 as_warn (_(".end directive has no name")); 2989 (void) restore_line_pointer (name_end); 2990 demand_empty_rest_of_line (); 2991 return; 2992 } 2993 2994 /* The value is the distance between the .end directive and the 2995 corresponding symbol. We create a fake symbol to hold the 2996 current location, and put in the offset when we write out the 2997 symbol. */ 2998 ent = symbol_find (name); 2999 if (ent == NULL) 3000 as_warn (_(".end directive names unknown symbol")); 3001 else 3002 (void) add_ecoff_symbol (NULL, st_End, sc_Text, 3003 symbol_new (FAKE_LABEL_NAME, now_seg, 3004 frag_now, frag_now_fix ()), 3005 0, 0, 0); 3006 3007 #ifdef md_flush_pending_output 3008 md_flush_pending_output (); 3009 #endif 3010 3011 cur_proc_ptr = NULL; 3012 3013 (void) restore_line_pointer (name_end); 3014 demand_empty_rest_of_line (); 3015 } 3016 3017 /* Parse .ent directives. */ 3019 3020 void 3021 ecoff_directive_ent (int aent) 3022 { 3023 char *name; 3024 char name_end; 3025 3026 if (cur_file_ptr == NULL) 3027 add_file (NULL, 0, 1); 3028 3029 if (!aent && cur_proc_ptr != NULL) 3030 { 3031 as_warn (_("second .ent directive found before .end directive")); 3032 demand_empty_rest_of_line (); 3033 return; 3034 } 3035 3036 name_end = get_symbol_name (&name); 3037 3038 if (name == input_line_pointer) 3039 { 3040 as_warn (_("%s directive has no name"), aent ? ".aent" : ".ent"); 3041 (void) restore_line_pointer (name_end); 3042 demand_empty_rest_of_line (); 3043 return; 3044 } 3045 3046 add_procedure (name, aent); 3047 3048 (void) restore_line_pointer (name_end); 3049 3050 /* The .ent directive is sometimes followed by a number. I'm not 3051 really sure what the number means. I don't see any way to store 3052 the information in the PDR. The Irix 4 assembler seems to ignore 3053 the information. */ 3054 SKIP_WHITESPACE (); 3055 if (*input_line_pointer == ',') 3056 { 3057 ++input_line_pointer; 3058 SKIP_WHITESPACE (); 3059 } 3060 if (ISDIGIT (*input_line_pointer) 3061 || *input_line_pointer == '-') 3062 (void) get_absolute_expression (); 3063 3064 demand_empty_rest_of_line (); 3065 } 3066 3067 /* Parse .extern directives. */ 3069 3070 void 3071 ecoff_directive_extern (int ignore ATTRIBUTE_UNUSED) 3072 { 3073 char *name; 3074 int c; 3075 symbolS *symbolp; 3076 valueT size; 3077 3078 c = get_symbol_name (&name); 3079 symbolp = symbol_find_or_make (name); 3080 (void) restore_line_pointer (c); 3081 3082 S_SET_EXTERNAL (symbolp); 3083 3084 if (*input_line_pointer == ',') 3085 ++input_line_pointer; 3086 size = get_absolute_expression (); 3087 3088 symbol_get_obj (symbolp)->ecoff_extern_size = size; 3089 } 3090 3091 /* Parse .file directives. */ 3093 3094 void 3095 ecoff_directive_file (int ignore ATTRIBUTE_UNUSED) 3096 { 3097 int indx; 3098 char *name; 3099 int len; 3100 3101 if (cur_proc_ptr != NULL) 3102 { 3103 as_warn (_("no way to handle .file within .ent/.end section")); 3104 demand_empty_rest_of_line (); 3105 return; 3106 } 3107 3108 indx = (int) get_absolute_expression (); 3109 3110 /* FIXME: we don't have to save the name here. */ 3111 name = demand_copy_C_string (&len); 3112 3113 add_file (name, indx - 1, 0); 3114 3115 demand_empty_rest_of_line (); 3116 } 3117 3118 /* Parse .fmask directives. */ 3120 3121 void 3122 ecoff_directive_fmask (int ignore ATTRIBUTE_UNUSED) 3123 { 3124 long val; 3125 3126 if (cur_proc_ptr == NULL) 3127 { 3128 as_warn (_(".fmask outside of .ent")); 3129 demand_empty_rest_of_line (); 3130 return; 3131 } 3132 3133 if (get_absolute_expression_and_terminator (&val) != ',') 3134 { 3135 as_warn (_("bad .fmask directive")); 3136 --input_line_pointer; 3137 demand_empty_rest_of_line (); 3138 return; 3139 } 3140 3141 cur_proc_ptr->pdr.fregmask = val; 3142 cur_proc_ptr->pdr.fregoffset = get_absolute_expression (); 3143 3144 demand_empty_rest_of_line (); 3145 } 3146 3147 /* Parse .frame directives. */ 3149 3150 void 3151 ecoff_directive_frame (int ignore ATTRIBUTE_UNUSED) 3152 { 3153 long val; 3154 3155 if (cur_proc_ptr == NULL) 3156 { 3157 as_warn (_(".frame outside of .ent")); 3158 demand_empty_rest_of_line (); 3159 return; 3160 } 3161 3162 cur_proc_ptr->pdr.framereg = tc_get_register (1); 3163 3164 SKIP_WHITESPACE (); 3165 if (*input_line_pointer++ != ',' 3166 || get_absolute_expression_and_terminator (&val) != ',') 3167 { 3168 as_warn (_("bad .frame directive")); 3169 --input_line_pointer; 3170 demand_empty_rest_of_line (); 3171 return; 3172 } 3173 3174 cur_proc_ptr->pdr.frameoffset = val; 3175 3176 cur_proc_ptr->pdr.pcreg = tc_get_register (0); 3177 3178 /* Alpha-OSF1 adds "the offset of saved $a0 from $sp", according to 3179 Sandro. I don't yet know where this value should be stored, if 3180 anywhere. Don't call demand_empty_rest_of_line (). */ 3181 s_ignore (42); 3182 } 3183 3184 /* Parse .mask directives. */ 3186 3187 void 3188 ecoff_directive_mask (int ignore ATTRIBUTE_UNUSED) 3189 { 3190 long val; 3191 3192 if (cur_proc_ptr == NULL) 3193 { 3194 as_warn (_(".mask outside of .ent")); 3195 demand_empty_rest_of_line (); 3196 return; 3197 } 3198 3199 if (get_absolute_expression_and_terminator (&val) != ',') 3200 { 3201 as_warn (_("bad .mask directive")); 3202 --input_line_pointer; 3203 demand_empty_rest_of_line (); 3204 return; 3205 } 3206 3207 cur_proc_ptr->pdr.regmask = val; 3208 cur_proc_ptr->pdr.regoffset = get_absolute_expression (); 3209 3210 demand_empty_rest_of_line (); 3211 } 3212 3213 /* Parse .loc directives. */ 3215 3216 void 3217 ecoff_directive_loc (int ignore ATTRIBUTE_UNUSED) 3218 { 3219 lineno_list_t *list; 3220 symint_t lineno; 3221 3222 if (cur_file_ptr == NULL) 3223 { 3224 as_warn (_(".loc before .file")); 3225 demand_empty_rest_of_line (); 3226 return; 3227 } 3228 3229 if (now_seg != text_section) 3230 { 3231 as_warn (_(".loc outside of .text")); 3232 demand_empty_rest_of_line (); 3233 return; 3234 } 3235 3236 /* Skip the file number. */ 3237 SKIP_WHITESPACE (); 3238 get_absolute_expression (); 3239 SKIP_WHITESPACE (); 3240 3241 lineno = get_absolute_expression (); 3242 3243 #ifndef NO_LISTING 3244 if (listing) 3245 listing_source_line (lineno); 3246 #endif 3247 3248 /* If we're building stabs, then output a special label rather than 3249 ECOFF line number info. */ 3250 if (stabs_seen) 3251 { 3252 (void) add_ecoff_symbol (NULL, st_Label, sc_Text, 3253 symbol_new (FAKE_LABEL_NAME, now_seg, 3254 frag_now, frag_now_fix ()), 3255 0, 0, lineno); 3256 return; 3257 } 3258 3259 list = allocate_lineno_list (); 3260 3261 list->next = NULL; 3262 list->file = cur_file_ptr; 3263 list->proc = cur_proc_ptr; 3264 list->frag = frag_now; 3265 list->paddr = frag_now_fix (); 3266 list->lineno = lineno; 3267 3268 /* We don't want to merge files which have line numbers. */ 3269 cur_file_ptr->fdr.fMerge = 0; 3270 3271 /* A .loc directive will sometimes appear before a .ent directive, 3272 which means that cur_proc_ptr will be NULL here. Arrange to 3273 patch this up. */ 3274 if (cur_proc_ptr == NULL) 3275 { 3276 lineno_list_t **pl; 3277 3278 pl = &noproc_lineno; 3279 while (*pl != NULL) 3280 pl = &(*pl)->next; 3281 *pl = list; 3282 } 3283 else 3284 { 3285 last_lineno = list; 3286 *last_lineno_ptr = list; 3287 last_lineno_ptr = &list->next; 3288 } 3289 } 3290 3291 /* The MIPS assembler sometimes inserts nop instructions in the 3292 instruction stream. When this happens, we must patch up the .loc 3293 information so that it points to the instruction after the nop. */ 3294 3295 void 3296 ecoff_fix_loc (fragS *old_frag, unsigned long old_frag_offset) 3297 { 3298 if (last_lineno != NULL 3299 && last_lineno->frag == old_frag 3300 && last_lineno->paddr == old_frag_offset) 3301 { 3302 last_lineno->frag = frag_now; 3303 last_lineno->paddr = frag_now_fix (); 3304 } 3305 } 3306 3307 /* Make sure the @stabs symbol is emitted. */ 3309 3310 static void 3311 mark_stabs (int ignore ATTRIBUTE_UNUSED) 3312 { 3313 if (! stabs_seen) 3314 { 3315 /* Add a dummy @stabs symbol. */ 3316 stabs_seen = 1; 3317 (void) add_ecoff_symbol (stabs_symbol, st_Nil, sc_Info, NULL, 0, -1, 3318 ECOFF_MARK_STAB (0)); 3319 } 3320 } 3321 3322 /* Parse .weakext directives. */ 3324 #ifndef TC_MIPS 3325 /* For TC_MIPS use the version in tc-mips.c. */ 3326 void 3327 ecoff_directive_weakext (int ignore ATTRIBUTE_UNUSED) 3328 { 3329 char *name; 3330 int c; 3331 symbolS *symbolP; 3332 expressionS exp; 3333 3334 c = get_symbol_name (&name); 3335 symbolP = symbol_find_or_make (name); 3336 (void) restore_line_pointer (c); 3337 3338 SKIP_WHITESPACE (); 3339 3340 if (*input_line_pointer == ',') 3341 { 3342 if (S_IS_DEFINED (symbolP)) 3343 { 3344 as_bad (_("symbol `%s' is already defined"), 3345 S_GET_NAME (symbolP)); 3346 ignore_rest_of_line (); 3347 return; 3348 } 3349 3350 ++input_line_pointer; 3351 SKIP_WHITESPACE (); 3352 if (! is_end_of_stmt (*input_line_pointer)) 3353 { 3354 expression (&exp); 3355 if (exp.X_op != O_symbol) 3356 { 3357 as_bad (_("bad .weakext directive")); 3358 ignore_rest_of_line (); 3359 return; 3360 } 3361 symbol_set_value_expression (symbolP, &exp); 3362 } 3363 } 3364 3365 S_SET_WEAK (symbolP); 3366 3367 demand_empty_rest_of_line (); 3368 } 3369 #endif /* not TC_MIPS */ 3370 3371 /* Handle .stabs directives. The actual parsing routine is done by a 3373 generic routine. This routine is called via OBJ_PROCESS_STAB. 3374 When this is called, input_line_pointer will be pointing at the 3375 value field of the stab. 3376 3377 .stabs directives have five fields: 3378 "string" a string, encoding the type information. 3379 code a numeric code, defined in <stab.h> 3380 0 a zero 3381 desc a zero or line number 3382 value a numeric value or an address. 3383 3384 If the value is relocatable, we transform this into: 3385 iss points as an index into string space 3386 value value from lookup of the name 3387 st st from lookup of the name 3388 sc sc from lookup of the name 3389 index code|CODE_MASK 3390 3391 If the value is not relocatable, we transform this into: 3392 iss points as an index into string space 3393 value value 3394 st st_Nil 3395 sc sc_Nil 3396 index code|CODE_MASK 3397 3398 .stabn directives have four fields (string is null): 3399 code a numeric code, defined in <stab.h> 3400 0 a zero 3401 desc a zero or a line number 3402 value a numeric value or an address. */ 3403 3404 void 3405 ecoff_stab (int what, 3406 const char *string, 3407 int type, 3408 int other, 3409 int desc) 3410 { 3411 efdr_t *save_file_ptr = cur_file_ptr; 3412 symbolS *sym; 3413 symint_t value; 3414 bfd_vma addend; 3415 st_t st; 3416 sc_t sc; 3417 symint_t indx; 3418 localsym_t *hold = NULL; 3419 3420 ecoff_debugging_seen = 1; 3421 3422 /* We don't handle .stabd. */ 3423 if (what != 's' && what != 'n') 3424 { 3425 as_bad (_(".stab%c is not supported"), what); 3426 return; 3427 } 3428 3429 /* A .stabn uses a null name, not an empty string. */ 3430 if (what == 'n') 3431 string = NULL; 3432 3433 /* We ignore the other field. */ 3434 if (other != 0) 3435 as_warn (_(".stab%c: ignoring non-zero other field"), what); 3436 3437 /* Make sure we have a current file. */ 3438 if (cur_file_ptr == NULL) 3439 { 3440 add_file (NULL, 0, 1); 3441 save_file_ptr = cur_file_ptr; 3442 } 3443 3444 /* For stabs in ECOFF, the first symbol must be @stabs. This is a 3445 signal to gdb. */ 3446 if (stabs_seen == 0) 3447 mark_stabs (0); 3448 3449 /* Line number stabs are handled differently, since they have two 3450 values, the line number and the address of the label. We use the 3451 index field (aka desc) to hold the line number, and the value 3452 field to hold the address. The symbol type is st_Label, which 3453 should be different from the other stabs, so that gdb can 3454 recognize it. */ 3455 if (type == N_SLINE) 3456 { 3457 SYMR dummy_symr; 3458 char *name; 3459 char name_end; 3460 3461 #ifndef NO_LISTING 3462 if (listing) 3463 listing_source_line (desc); 3464 #endif 3465 3466 dummy_symr.index = desc; 3467 if (dummy_symr.index != desc) 3468 { 3469 as_warn (_("line number (%d) for .stab%c directive cannot fit in index field (20 bits)"), 3470 desc, what); 3471 return; 3472 } 3473 3474 name_end = get_symbol_name (&name); 3475 sym = symbol_find_or_make (name); 3476 (void) restore_line_pointer (name_end); 3477 3478 value = 0; 3479 addend = 0; 3480 st = st_Label; 3481 sc = sc_Text; 3482 indx = desc; 3483 } 3484 else 3485 { 3486 #ifndef NO_LISTING 3487 if (listing && (type == N_SO || type == N_SOL)) 3488 listing_source_file (string); 3489 #endif 3490 3491 if (ISDIGIT (*input_line_pointer) 3492 || *input_line_pointer == '-' 3493 || *input_line_pointer == '+') 3494 { 3495 st = st_Nil; 3496 sc = sc_Nil; 3497 sym = NULL; 3498 value = get_absolute_expression (); 3499 addend = 0; 3500 } 3501 else if (! is_name_beginner (*input_line_pointer)) 3502 { 3503 as_warn (_("illegal .stab%c directive, bad character"), what); 3504 return; 3505 } 3506 else 3507 { 3508 expressionS exp; 3509 3510 sc = sc_Nil; 3511 st = st_Nil; 3512 3513 expression (&exp); 3514 if (exp.X_op == O_constant) 3515 { 3516 sym = NULL; 3517 value = exp.X_add_number; 3518 addend = 0; 3519 } 3520 else if (exp.X_op == O_symbol) 3521 { 3522 sym = exp.X_add_symbol; 3523 value = 0; 3524 addend = exp.X_add_number; 3525 } 3526 else 3527 { 3528 sym = make_expr_symbol (&exp); 3529 value = 0; 3530 addend = 0; 3531 } 3532 } 3533 3534 indx = ECOFF_MARK_STAB (type); 3535 } 3536 3537 /* Don't store the stabs symbol we are creating as the type of the 3538 ECOFF symbol. We want to compute the type of the ECOFF symbol 3539 independently. */ 3540 if (sym != NULL) 3541 hold = symbol_get_obj (sym)->ecoff_symbol; 3542 3543 (void) add_ecoff_symbol (string, st, sc, sym, addend, value, indx); 3544 3545 if (sym != NULL) 3546 symbol_get_obj (sym)->ecoff_symbol = hold; 3547 3548 /* Restore normal file type. */ 3549 cur_file_ptr = save_file_ptr; 3550 } 3551 3552 /* Frob an ECOFF symbol. Small common symbols go into a special 3554 .scommon section rather than bfd_com_section. */ 3555 3556 void 3557 ecoff_frob_symbol (symbolS *sym) 3558 { 3559 if (S_IS_COMMON (sym) 3560 && S_GET_VALUE (sym) > 0 3561 && S_GET_VALUE (sym) <= bfd_get_gp_size (stdoutput)) 3562 { 3563 S_SET_SEGMENT (sym, &_bfd_ecoff_scom_section); 3564 } 3565 3566 /* Double check weak symbols. */ 3567 if (S_IS_WEAK (sym)) 3568 { 3569 if (S_IS_COMMON (sym)) 3570 as_bad (_("symbol `%s' can not be both weak and common"), 3571 S_GET_NAME (sym)); 3572 } 3573 } 3574 3575 /* Add bytes to the symbolic information buffer. */ 3577 3578 static char * 3579 ecoff_add_bytes (char **buf, 3580 char **bufend, 3581 char *bufptr, 3582 unsigned long need) 3583 { 3584 unsigned long at; 3585 unsigned long want; 3586 3587 at = bufptr - *buf; 3588 need -= *bufend - bufptr; 3589 if (need < PAGE_SIZE) 3590 need = PAGE_SIZE; 3591 want = (*bufend - *buf) + need; 3592 *buf = XRESIZEVEC (char, *buf, want); 3593 *bufend = *buf + want; 3594 return *buf + at; 3595 } 3596 3597 /* Adjust the symbolic information buffer to the alignment required 3598 for the ECOFF target debugging information. */ 3599 3600 static unsigned long 3601 ecoff_padding_adjust (const struct ecoff_debug_swap *backend, 3602 char **buf, 3603 char **bufend, 3604 unsigned long offset, 3605 char **bufptrptr) 3606 { 3607 bfd_size_type align; 3608 3609 align = backend->debug_align; 3610 if ((offset & (align - 1)) != 0) 3611 { 3612 unsigned long add; 3613 3614 add = align - (offset & (align - 1)); 3615 if ((unsigned long) (*bufend - (*buf + offset)) < add) 3616 (void) ecoff_add_bytes (buf, bufend, *buf + offset, add); 3617 memset (*buf + offset, 0, add); 3618 offset += add; 3619 if (bufptrptr != NULL) 3620 *bufptrptr = *buf + offset; 3621 } 3622 3623 return offset; 3624 } 3625 3626 /* Build the line number information. */ 3627 3628 static unsigned long 3629 ecoff_build_lineno (const struct ecoff_debug_swap *backend, 3630 char **buf, 3631 char **bufend, 3632 unsigned long offset, 3633 long *linecntptr) 3634 { 3635 char *bufptr; 3636 lineno_list_t *l; 3637 lineno_list_t *last; 3638 efdr_t *file; 3639 proc_t *proc; 3640 unsigned long c; 3641 long iline; 3642 long totcount; 3643 lineno_list_t first; 3644 lineno_list_t *local_first_lineno = first_lineno; 3645 3646 if (linecntptr != NULL) 3647 *linecntptr = 0; 3648 3649 bufptr = *buf + offset; 3650 3651 file = NULL; 3652 proc = NULL; 3653 last = NULL; 3654 c = offset; 3655 iline = 0; 3656 totcount = 0; 3657 3658 /* FIXME? Now that MIPS embedded-PIC is gone, it may be safe to 3659 remove this code. */ 3660 /* For some reason the address of the first procedure is ignored 3661 when reading line numbers. This doesn't matter if the address of 3662 the first procedure is 0, but when gcc is generating MIPS 3663 embedded PIC code, it will put strings in the .text section 3664 before the first procedure. We cope by inserting a dummy line if 3665 the address of the first procedure is not 0. Hopefully this 3666 won't screw things up too badly. 3667 3668 Don't do this for ECOFF assembly source line numbers. They work 3669 without this extra attention. */ 3670 if (debug_type != DEBUG_ECOFF 3671 && first_proc_ptr != NULL 3672 && local_first_lineno != NULL 3673 && ((S_GET_VALUE (first_proc_ptr->sym->as_sym) 3674 + bfd_section_vma (S_GET_SEGMENT (first_proc_ptr->sym->as_sym))) 3675 != 0)) 3676 { 3677 first.file = local_first_lineno->file; 3678 first.proc = local_first_lineno->proc; 3679 first.frag = &zero_address_frag; 3680 first.paddr = 0; 3681 first.lineno = 0; 3682 3683 first.next = local_first_lineno; 3684 local_first_lineno = &first; 3685 } 3686 3687 for (l = local_first_lineno; l != NULL; l = l->next) 3688 { 3689 long count; 3690 long delta; 3691 3692 /* Get the offset to the memory address of the next line number 3693 (in words). Do this first, so that we can skip ahead to the 3694 next useful line number entry. */ 3695 if (l->next == NULL) 3696 { 3697 /* We want a count of zero, but it will be decremented 3698 before it is used. */ 3699 count = 1; 3700 } 3701 else if (l->next->frag->fr_address + l->next->paddr 3702 > l->frag->fr_address + l->paddr) 3703 { 3704 count = (l->next->frag->fr_address + l->next->paddr 3705 - (l->frag->fr_address + l->paddr)) >> 2; 3706 } 3707 else 3708 { 3709 /* Don't change last, so we still get the right delta. */ 3710 continue; 3711 } 3712 3713 if (l->file != file || l->proc != proc) 3714 { 3715 if (l->proc != proc && proc != NULL) 3716 proc->pdr.lnHigh = last->lineno; 3717 if (l->file != file && file != NULL) 3718 { 3719 file->fdr.cbLine = c - file->fdr.cbLineOffset; 3720 file->fdr.cline = totcount + count; 3721 if (linecntptr != NULL) 3722 *linecntptr += totcount + count; 3723 totcount = 0; 3724 } 3725 3726 if (l->file != file) 3727 { 3728 efdr_t *last_file = file; 3729 3730 file = l->file; 3731 if (last_file != NULL) 3732 file->fdr.ilineBase 3733 = last_file->fdr.ilineBase + last_file->fdr.cline; 3734 else 3735 file->fdr.ilineBase = 0; 3736 file->fdr.cbLineOffset = c; 3737 } 3738 if (l->proc != proc) 3739 { 3740 proc = l->proc; 3741 if (proc != NULL) 3742 { 3743 proc->pdr.lnLow = l->lineno; 3744 proc->pdr.cbLineOffset = c - file->fdr.cbLineOffset; 3745 proc->pdr.iline = totcount; 3746 } 3747 } 3748 3749 last = NULL; 3750 } 3751 3752 totcount += count; 3753 3754 /* Get the offset to this line number. */ 3755 if (last == NULL) 3756 delta = 0; 3757 else 3758 delta = l->lineno - last->lineno; 3759 3760 /* Put in the offset to this line number. */ 3761 while (delta != 0) 3762 { 3763 int setcount; 3764 3765 /* 1 is added to each count read. */ 3766 --count; 3767 /* We can only adjust the word count by up to 15 words at a 3768 time. */ 3769 if (count <= 0x0f) 3770 { 3771 setcount = count; 3772 count = 0; 3773 } 3774 else 3775 { 3776 setcount = 0x0f; 3777 count -= 0x0f; 3778 } 3779 if (delta >= -7 && delta <= 7) 3780 { 3781 if (bufptr >= *bufend) 3782 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 1); 3783 *bufptr++ = setcount + (delta << 4); 3784 delta = 0; 3785 ++c; 3786 } 3787 else 3788 { 3789 int set; 3790 3791 if (*bufend - bufptr < 3) 3792 bufptr = ecoff_add_bytes (buf, bufend, bufptr, (long) 3); 3793 *bufptr++ = setcount + (8 << 4); 3794 if (delta < -0x8000) 3795 { 3796 set = -0x8000; 3797 delta += 0x8000; 3798 } 3799 else if (delta > 0x7fff) 3800 { 3801 set = 0x7fff; 3802 delta -= 0x7fff; 3803 } 3804 else 3805 { 3806 set = delta; 3807 delta = 0; 3808 } 3809 *bufptr++ = set >> 8; 3810 *bufptr++ = set & 0xffff; 3811 c += 3; 3812 } 3813 } 3814 3815 /* Finish adjusting the count. */ 3816 while (count > 0) 3817 { 3818 if (bufptr >= *bufend) 3819 bufptr = ecoff_add_bytes (buf, bufend, bufptr, 1); 3820 /* 1 is added to each count read. */ 3821 --count; 3822 if (count > 0x0f) 3823 { 3824 *bufptr++ = 0x0f; 3825 count -= 0x0f; 3826 } 3827 else 3828 { 3829 *bufptr++ = count; 3830 count = 0; 3831 } 3832 ++c; 3833 } 3834 3835 ++iline; 3836 last = l; 3837 } 3838 3839 if (proc != NULL) 3840 proc->pdr.lnHigh = last->lineno; 3841 if (file != NULL) 3842 { 3843 file->fdr.cbLine = c - file->fdr.cbLineOffset; 3844 file->fdr.cline = totcount; 3845 } 3846 3847 if (linecntptr != NULL) 3848 *linecntptr += totcount; 3849 3850 c = ecoff_padding_adjust (backend, buf, bufend, c, &bufptr); 3851 3852 return c; 3853 } 3854 3855 /* Build and swap out the symbols. */ 3856 3857 static unsigned long 3858 ecoff_build_symbols (const struct ecoff_debug_swap *backend, 3859 char **buf, 3860 char **bufend, 3861 unsigned long offset) 3862 { 3863 const bfd_size_type external_sym_size = backend->external_sym_size; 3864 void (* const swap_sym_out) (bfd *, const SYMR *, void *) 3865 = backend->swap_sym_out; 3866 char *sym_out; 3867 long isym; 3868 vlinks_t *file_link; 3869 3870 sym_out = *buf + offset; 3871 3872 isym = 0; 3873 3874 /* The symbols are stored by file. */ 3875 for (file_link = file_desc.first; 3876 file_link != NULL; 3877 file_link = file_link->next) 3878 { 3879 int ifilesym; 3880 int fil_cnt; 3881 efdr_t *fil_ptr; 3882 efdr_t *fil_end; 3883 3884 if (file_link->next == NULL) 3885 fil_cnt = file_desc.objects_last_page; 3886 else 3887 fil_cnt = file_desc.objects_per_page; 3888 fil_ptr = file_link->datum->file; 3889 fil_end = fil_ptr + fil_cnt; 3890 for (; fil_ptr < fil_end; fil_ptr++) 3891 { 3892 vlinks_t *sym_link; 3893 3894 fil_ptr->fdr.isymBase = isym; 3895 ifilesym = isym; 3896 for (sym_link = fil_ptr->symbols.first; 3897 sym_link != NULL; 3898 sym_link = sym_link->next) 3899 { 3900 int sym_cnt; 3901 localsym_t *sym_ptr; 3902 localsym_t *sym_end; 3903 3904 if (sym_link->next == NULL) 3905 sym_cnt = fil_ptr->symbols.objects_last_page; 3906 else 3907 sym_cnt = fil_ptr->symbols.objects_per_page; 3908 sym_ptr = sym_link->datum->sym; 3909 sym_end = sym_ptr + sym_cnt; 3910 for (; sym_ptr < sym_end; sym_ptr++) 3911 { 3912 int local; 3913 symbolS *as_sym; 3914 forward_t *f; 3915 3916 know (sym_ptr->file_ptr == fil_ptr); 3917 3918 /* If there is no associated gas symbol, then this 3919 is a pure debugging symbol. We have already 3920 added the name (if any) to fil_ptr->strings. 3921 Otherwise we must decide whether this is an 3922 external or a local symbol (actually, it may be 3923 both if the local provides additional debugging 3924 information for the external). */ 3925 local = 1; 3926 as_sym = sym_ptr->as_sym; 3927 if (as_sym != NULL) 3928 { 3929 symint_t indx; 3930 3931 /* The value of a block start symbol is the 3932 offset from the start of the procedure. For 3933 other symbols we just use the gas value (but 3934 we must offset it by the vma of the section, 3935 just as BFD does, because BFD will not see 3936 this value). */ 3937 if (sym_ptr->ecoff_sym.asym.st == st_Block 3938 && sym_ptr->ecoff_sym.asym.sc == sc_Text) 3939 { 3940 symbolS *begin_sym; 3941 3942 know (sym_ptr->proc_ptr != NULL); 3943 begin_sym = sym_ptr->proc_ptr->sym->as_sym; 3944 if (S_GET_SEGMENT (as_sym) 3945 != S_GET_SEGMENT (begin_sym)) 3946 as_warn (_(".begin/.bend in different segments")); 3947 sym_ptr->ecoff_sym.asym.value = 3948 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym); 3949 } 3950 else 3951 sym_ptr->ecoff_sym.asym.value = 3952 (S_GET_VALUE (as_sym) 3953 + bfd_section_vma (S_GET_SEGMENT (as_sym)) 3954 + sym_ptr->addend); 3955 3956 sym_ptr->ecoff_sym.weakext = S_IS_WEAK (as_sym); 3957 3958 /* Set st_Proc to st_StaticProc for local 3959 functions. */ 3960 if (sym_ptr->ecoff_sym.asym.st == st_Proc 3961 && S_IS_DEFINED (as_sym) 3962 && ! S_IS_EXTERNAL (as_sym) 3963 && ! S_IS_WEAK (as_sym)) 3964 sym_ptr->ecoff_sym.asym.st = st_StaticProc; 3965 3966 /* Get the type and storage class based on where 3967 the symbol actually wound up. Traditionally, 3968 N_LBRAC and N_RBRAC are *not* relocated. */ 3969 indx = sym_ptr->ecoff_sym.asym.index; 3970 if (sym_ptr->ecoff_sym.asym.st == st_Nil 3971 && sym_ptr->ecoff_sym.asym.sc == sc_Nil 3972 && (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym) 3973 || ((ECOFF_UNMARK_STAB (indx) != N_LBRAC) 3974 && (ECOFF_UNMARK_STAB (indx) != N_RBRAC)))) 3975 { 3976 segT seg; 3977 const char *segname; 3978 st_t st; 3979 sc_t sc; 3980 3981 seg = S_GET_SEGMENT (as_sym); 3982 segname = segment_name (seg); 3983 3984 if (! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym) 3985 && (S_IS_EXTERNAL (as_sym) 3986 || S_IS_WEAK (as_sym) 3987 || ! S_IS_DEFINED (as_sym))) 3988 { 3989 if ((symbol_get_bfdsym (as_sym)->flags 3990 & BSF_FUNCTION) != 0) 3991 st = st_Proc; 3992 else 3993 st = st_Global; 3994 } 3995 else if (seg == text_section) 3996 st = st_Label; 3997 else 3998 st = st_Static; 3999 4000 if (! S_IS_DEFINED (as_sym)) 4001 { 4002 valueT s; 4003 4004 s = symbol_get_obj (as_sym)->ecoff_extern_size; 4005 if (s == 0 4006 || s > bfd_get_gp_size (stdoutput)) 4007 sc = sc_Undefined; 4008 else 4009 { 4010 sc = sc_SUndefined; 4011 sym_ptr->ecoff_sym.asym.value = s; 4012 } 4013 #ifdef S_SET_SIZE 4014 S_SET_SIZE (as_sym, s); 4015 #endif 4016 } 4017 else if (S_IS_COMMON (as_sym)) 4018 { 4019 if (S_GET_VALUE (as_sym) > 0 4020 && (S_GET_VALUE (as_sym) 4021 <= bfd_get_gp_size (stdoutput))) 4022 sc = sc_SCommon; 4023 else 4024 sc = sc_Common; 4025 } 4026 else if (seg == text_section) 4027 sc = sc_Text; 4028 else if (seg == data_section) 4029 sc = sc_Data; 4030 else if (strcmp (segname, ".rdata") == 0 4031 || strcmp (segname, ".rodata") == 0) 4032 sc = sc_RData; 4033 else if (strcmp (segname, ".sdata") == 0) 4034 sc = sc_SData; 4035 else if (seg == bss_section) 4036 sc = sc_Bss; 4037 else if (strcmp (segname, ".sbss") == 0) 4038 sc = sc_SBss; 4039 else if (seg == bfd_abs_section_ptr) 4040 sc = sc_Abs; 4041 else 4042 { 4043 /* This must be a user named section. 4044 This is not possible in ECOFF, but it 4045 is in ELF. */ 4046 sc = sc_Data; 4047 } 4048 4049 sym_ptr->ecoff_sym.asym.st = st; 4050 sym_ptr->ecoff_sym.asym.sc = sc; 4051 } 4052 4053 /* This is just an external symbol if it is 4054 outside a procedure and it has a type. 4055 FIXME: g++ will generate symbols which have 4056 different names in the debugging information 4057 than the actual symbol. Should we handle 4058 them here? */ 4059 if ((S_IS_EXTERNAL (as_sym) 4060 || S_IS_WEAK (as_sym) 4061 || ! S_IS_DEFINED (as_sym)) 4062 && sym_ptr->proc_ptr == NULL 4063 && sym_ptr->ecoff_sym.asym.st != st_Nil 4064 && ! ECOFF_IS_STAB (&sym_ptr->ecoff_sym.asym)) 4065 local = 0; 4066 4067 /* This is just an external symbol if it is a 4068 common symbol. */ 4069 if (S_IS_COMMON (as_sym)) 4070 local = 0; 4071 4072 /* If an st_end symbol has an associated gas 4073 symbol, then it is a local label created for 4074 a .bend or .end directive. Stabs line 4075 numbers will have FAKE_LABEL_CHAR in the names. */ 4076 if (local 4077 && sym_ptr->ecoff_sym.asym.st != st_End 4078 && strchr (sym_ptr->name, FAKE_LABEL_CHAR) == 0) 4079 sym_ptr->ecoff_sym.asym.iss = 4080 add_string (&fil_ptr->strings, 4081 fil_ptr->str_hash, 4082 sym_ptr->name, 4083 NULL); 4084 } 4085 4086 /* We now know the index of this symbol; fill in 4087 locations that have been waiting for that 4088 information. */ 4089 if (sym_ptr->begin_ptr != NULL) 4090 { 4091 localsym_t *begin_ptr; 4092 st_t begin_type; 4093 4094 know (local); 4095 begin_ptr = sym_ptr->begin_ptr; 4096 know (begin_ptr->sym_index != -1); 4097 sym_ptr->ecoff_sym.asym.index = begin_ptr->sym_index; 4098 if (sym_ptr->ecoff_sym.asym.sc != sc_Info) 4099 sym_ptr->ecoff_sym.asym.iss = 4100 begin_ptr->ecoff_sym.asym.iss; 4101 4102 begin_type = (st_t) begin_ptr->ecoff_sym.asym.st; 4103 if (begin_type == st_File 4104 || begin_type == st_Block) 4105 { 4106 begin_ptr->ecoff_sym.asym.index = 4107 isym - ifilesym + 1; 4108 (*swap_sym_out) (stdoutput, 4109 &begin_ptr->ecoff_sym.asym, 4110 (*buf 4111 + offset 4112 + (begin_ptr->sym_index 4113 * external_sym_size))); 4114 } 4115 else 4116 { 4117 know (begin_ptr->index_ptr != NULL); 4118 begin_ptr->index_ptr->data.isym = 4119 isym - ifilesym + 1; 4120 } 4121 4122 /* The value of the symbol marking the end of a 4123 procedure is the size of the procedure. The 4124 value of the symbol marking the end of a 4125 block is the offset from the start of the 4126 procedure to the block. */ 4127 if (begin_type == st_Proc 4128 || begin_type == st_StaticProc) 4129 { 4130 know (as_sym != NULL); 4131 know (begin_ptr->as_sym != NULL); 4132 if (S_GET_SEGMENT (as_sym) 4133 != S_GET_SEGMENT (begin_ptr->as_sym)) 4134 as_warn (_(".begin/.bend in different segments")); 4135 sym_ptr->ecoff_sym.asym.value = 4136 (S_GET_VALUE (as_sym) 4137 - S_GET_VALUE (begin_ptr->as_sym)); 4138 4139 /* If the size is odd, this is probably a 4140 mips16 function; force it to be even. */ 4141 if ((sym_ptr->ecoff_sym.asym.value & 1) != 0) 4142 ++sym_ptr->ecoff_sym.asym.value; 4143 4144 #ifdef S_SET_SIZE 4145 S_SET_SIZE (begin_ptr->as_sym, 4146 sym_ptr->ecoff_sym.asym.value); 4147 #endif 4148 } 4149 else if (begin_type == st_Block 4150 && sym_ptr->ecoff_sym.asym.sc != sc_Info) 4151 { 4152 symbolS *begin_sym; 4153 4154 know (as_sym != NULL); 4155 know (sym_ptr->proc_ptr != NULL); 4156 begin_sym = sym_ptr->proc_ptr->sym->as_sym; 4157 if (S_GET_SEGMENT (as_sym) 4158 != S_GET_SEGMENT (begin_sym)) 4159 as_warn (_(".begin/.bend in different segments")); 4160 sym_ptr->ecoff_sym.asym.value = 4161 S_GET_VALUE (as_sym) - S_GET_VALUE (begin_sym); 4162 } 4163 } 4164 4165 for (f = sym_ptr->forward_ref; 4166 f != NULL; 4167 f = f->next) 4168 { 4169 know (local); 4170 f->ifd_ptr->data.isym = fil_ptr->file_index; 4171 f->index_ptr->data.rndx.index = isym - ifilesym; 4172 } 4173 4174 if (local) 4175 { 4176 if ((bfd_size_type)(*bufend - sym_out) < external_sym_size) 4177 sym_out = ecoff_add_bytes (buf, bufend, 4178 sym_out, 4179 external_sym_size); 4180 (*swap_sym_out) (stdoutput, &sym_ptr->ecoff_sym.asym, 4181 sym_out); 4182 sym_out += external_sym_size; 4183 4184 sym_ptr->sym_index = isym; 4185 4186 if (sym_ptr->proc_ptr != NULL 4187 && sym_ptr->proc_ptr->sym == sym_ptr) 4188 sym_ptr->proc_ptr->pdr.isym = isym - ifilesym; 4189 4190 ++isym; 4191 } 4192 4193 /* Record the local symbol index and file number in 4194 case this is an external symbol. Note that this 4195 destroys the asym.index field. */ 4196 if (as_sym != NULL 4197 && symbol_get_obj (as_sym)->ecoff_symbol == sym_ptr) 4198 { 4199 if ((sym_ptr->ecoff_sym.asym.st == st_Proc 4200 || sym_ptr->ecoff_sym.asym.st == st_StaticProc) 4201 && local) 4202 sym_ptr->ecoff_sym.asym.index = isym - ifilesym - 1; 4203 sym_ptr->ecoff_sym.ifd = fil_ptr->file_index; 4204 4205 /* Don't try to merge an FDR which has an 4206 external symbol attached to it. */ 4207 if (S_IS_EXTERNAL (as_sym) || S_IS_WEAK (as_sym)) 4208 fil_ptr->fdr.fMerge = 0; 4209 } 4210 } 4211 } 4212 fil_ptr->fdr.csym = isym - fil_ptr->fdr.isymBase; 4213 } 4214 } 4215 4216 return offset + isym * external_sym_size; 4217 } 4218 4219 /* Swap out the procedure information. */ 4220 4221 static unsigned long 4222 ecoff_build_procs (const struct ecoff_debug_swap *backend, 4223 char **buf, 4224 char **bufend, 4225 unsigned long offset) 4226 { 4227 const bfd_size_type external_pdr_size = backend->external_pdr_size; 4228 void (* const swap_pdr_out) (bfd *, const PDR *, void *) 4229 = backend->swap_pdr_out; 4230 char *pdr_out; 4231 long iproc; 4232 vlinks_t *file_link; 4233 4234 pdr_out = *buf + offset; 4235 4236 iproc = 0; 4237 4238 /* The procedures are stored by file. */ 4239 for (file_link = file_desc.first; 4240 file_link != NULL; 4241 file_link = file_link->next) 4242 { 4243 int fil_cnt; 4244 efdr_t *fil_ptr; 4245 efdr_t *fil_end; 4246 4247 if (file_link->next == NULL) 4248 fil_cnt = file_desc.objects_last_page; 4249 else 4250 fil_cnt = file_desc.objects_per_page; 4251 fil_ptr = file_link->datum->file; 4252 fil_end = fil_ptr + fil_cnt; 4253 for (; fil_ptr < fil_end; fil_ptr++) 4254 { 4255 vlinks_t *proc_link; 4256 int first; 4257 4258 fil_ptr->fdr.ipdFirst = iproc; 4259 first = 1; 4260 for (proc_link = fil_ptr->procs.first; 4261 proc_link != NULL; 4262 proc_link = proc_link->next) 4263 { 4264 int prc_cnt; 4265 proc_t *proc_ptr; 4266 proc_t *proc_end; 4267 4268 if (proc_link->next == NULL) 4269 prc_cnt = fil_ptr->procs.objects_last_page; 4270 else 4271 prc_cnt = fil_ptr->procs.objects_per_page; 4272 proc_ptr = proc_link->datum->proc; 4273 proc_end = proc_ptr + prc_cnt; 4274 for (; proc_ptr < proc_end; proc_ptr++) 4275 { 4276 symbolS *adr_sym; 4277 unsigned long adr; 4278 4279 adr_sym = proc_ptr->sym->as_sym; 4280 adr = (S_GET_VALUE (adr_sym) 4281 + bfd_section_vma (S_GET_SEGMENT (adr_sym))); 4282 if (first) 4283 { 4284 /* This code used to force the adr of the very 4285 first fdr to be 0. However, the native tools 4286 don't do that, and I can't remember why it 4287 used to work that way, so I took it out. */ 4288 fil_ptr->fdr.adr = adr; 4289 first = 0; 4290 } 4291 proc_ptr->pdr.adr = adr - fil_ptr->fdr.adr; 4292 if ((bfd_size_type)(*bufend - pdr_out) < external_pdr_size) 4293 pdr_out = ecoff_add_bytes (buf, bufend, 4294 pdr_out, 4295 external_pdr_size); 4296 (*swap_pdr_out) (stdoutput, &proc_ptr->pdr, pdr_out); 4297 pdr_out += external_pdr_size; 4298 ++iproc; 4299 } 4300 } 4301 fil_ptr->fdr.cpd = iproc - fil_ptr->fdr.ipdFirst; 4302 } 4303 } 4304 4305 return offset + iproc * external_pdr_size; 4306 } 4307 4308 /* Swap out the aux information. */ 4309 4310 static unsigned long 4311 ecoff_build_aux (const struct ecoff_debug_swap *backend, 4312 char **buf, 4313 char **bufend, 4314 unsigned long offset) 4315 { 4316 int bigendian; 4317 union aux_ext *aux_out; 4318 long iaux; 4319 vlinks_t *file_link; 4320 4321 bigendian = bfd_big_endian (stdoutput); 4322 4323 aux_out = (union aux_ext *) (*buf + offset); 4324 4325 iaux = 0; 4326 4327 /* The aux entries are stored by file. */ 4328 for (file_link = file_desc.first; 4329 file_link != NULL; 4330 file_link = file_link->next) 4331 { 4332 int fil_cnt; 4333 efdr_t *fil_ptr; 4334 efdr_t *fil_end; 4335 4336 if (file_link->next == NULL) 4337 fil_cnt = file_desc.objects_last_page; 4338 else 4339 fil_cnt = file_desc.objects_per_page; 4340 fil_ptr = file_link->datum->file; 4341 fil_end = fil_ptr + fil_cnt; 4342 for (; fil_ptr < fil_end; fil_ptr++) 4343 { 4344 vlinks_t *aux_link; 4345 4346 fil_ptr->fdr.fBigendian = bigendian; 4347 fil_ptr->fdr.iauxBase = iaux; 4348 for (aux_link = fil_ptr->aux_syms.first; 4349 aux_link != NULL; 4350 aux_link = aux_link->next) 4351 { 4352 int aux_cnt; 4353 aux_t *aux_ptr; 4354 aux_t *aux_end; 4355 4356 if (aux_link->next == NULL) 4357 aux_cnt = fil_ptr->aux_syms.objects_last_page; 4358 else 4359 aux_cnt = fil_ptr->aux_syms.objects_per_page; 4360 aux_ptr = aux_link->datum->aux; 4361 aux_end = aux_ptr + aux_cnt; 4362 for (; aux_ptr < aux_end; aux_ptr++) 4363 { 4364 if ((unsigned long) (*bufend - (char *) aux_out) 4365 < sizeof (union aux_ext)) 4366 aux_out = ((union aux_ext *) 4367 ecoff_add_bytes (buf, bufend, 4368 (char *) aux_out, 4369 sizeof (union aux_ext))); 4370 switch (aux_ptr->type) 4371 { 4372 case aux_tir: 4373 (*backend->swap_tir_out) (bigendian, 4374 &aux_ptr->data.ti, 4375 &aux_out->a_ti); 4376 break; 4377 case aux_rndx: 4378 (*backend->swap_rndx_out) (bigendian, 4379 &aux_ptr->data.rndx, 4380 &aux_out->a_rndx); 4381 break; 4382 case aux_dnLow: 4383 AUX_PUT_DNLOW (bigendian, aux_ptr->data.dnLow, 4384 aux_out); 4385 break; 4386 case aux_dnHigh: 4387 AUX_PUT_DNHIGH (bigendian, aux_ptr->data.dnHigh, 4388 aux_out); 4389 break; 4390 case aux_isym: 4391 AUX_PUT_ISYM (bigendian, aux_ptr->data.isym, 4392 aux_out); 4393 break; 4394 case aux_iss: 4395 AUX_PUT_ISS (bigendian, aux_ptr->data.iss, 4396 aux_out); 4397 break; 4398 case aux_width: 4399 AUX_PUT_WIDTH (bigendian, aux_ptr->data.width, 4400 aux_out); 4401 break; 4402 case aux_count: 4403 AUX_PUT_COUNT (bigendian, aux_ptr->data.count, 4404 aux_out); 4405 break; 4406 } 4407 4408 ++aux_out; 4409 ++iaux; 4410 } 4411 } 4412 fil_ptr->fdr.caux = iaux - fil_ptr->fdr.iauxBase; 4413 } 4414 } 4415 4416 return ecoff_padding_adjust (backend, buf, bufend, 4417 offset + iaux * sizeof (union aux_ext), 4418 NULL); 4419 } 4420 4421 /* Copy out the strings from a varray_t. This returns the number of 4422 bytes copied, rather than the new offset. */ 4423 4424 static unsigned long 4425 ecoff_build_strings (char **buf, 4426 char **bufend, 4427 unsigned long offset, 4428 varray_t *vp) 4429 { 4430 unsigned long istr; 4431 char *str_out; 4432 vlinks_t *str_link; 4433 4434 str_out = *buf + offset; 4435 4436 istr = 0; 4437 4438 for (str_link = vp->first; 4439 str_link != NULL; 4440 str_link = str_link->next) 4441 { 4442 unsigned long str_cnt; 4443 4444 if (str_link->next == NULL) 4445 str_cnt = vp->objects_last_page; 4446 else 4447 str_cnt = vp->objects_per_page; 4448 4449 if ((unsigned long)(*bufend - str_out) < str_cnt) 4450 str_out = ecoff_add_bytes (buf, bufend, str_out, str_cnt); 4451 4452 memcpy (str_out, str_link->datum->byte, str_cnt); 4453 str_out += str_cnt; 4454 istr += str_cnt; 4455 } 4456 4457 return istr; 4458 } 4459 4460 /* Dump out the local strings. */ 4461 4462 static unsigned long 4463 ecoff_build_ss (const struct ecoff_debug_swap *backend, 4464 char **buf, 4465 char **bufend, 4466 unsigned long offset) 4467 { 4468 long iss; 4469 vlinks_t *file_link; 4470 4471 iss = 0; 4472 4473 for (file_link = file_desc.first; 4474 file_link != NULL; 4475 file_link = file_link->next) 4476 { 4477 int fil_cnt; 4478 efdr_t *fil_ptr; 4479 efdr_t *fil_end; 4480 4481 if (file_link->next == NULL) 4482 fil_cnt = file_desc.objects_last_page; 4483 else 4484 fil_cnt = file_desc.objects_per_page; 4485 fil_ptr = file_link->datum->file; 4486 fil_end = fil_ptr + fil_cnt; 4487 for (; fil_ptr < fil_end; fil_ptr++) 4488 { 4489 long ss_cnt; 4490 4491 fil_ptr->fdr.issBase = iss; 4492 ss_cnt = ecoff_build_strings (buf, bufend, offset + iss, 4493 &fil_ptr->strings); 4494 fil_ptr->fdr.cbSs = ss_cnt; 4495 iss += ss_cnt; 4496 } 4497 } 4498 4499 return ecoff_padding_adjust (backend, buf, bufend, offset + iss, NULL); 4500 } 4501 4502 /* Swap out the file descriptors. */ 4503 4504 static unsigned long 4505 ecoff_build_fdr (const struct ecoff_debug_swap *backend, 4506 char **buf, 4507 char **bufend, 4508 unsigned long offset) 4509 { 4510 const bfd_size_type external_fdr_size = backend->external_fdr_size; 4511 void (* const swap_fdr_out) (bfd *, const FDR *, void *) 4512 = backend->swap_fdr_out; 4513 long ifile; 4514 char *fdr_out; 4515 vlinks_t *file_link; 4516 4517 ifile = 0; 4518 4519 fdr_out = *buf + offset; 4520 4521 for (file_link = file_desc.first; 4522 file_link != NULL; 4523 file_link = file_link->next) 4524 { 4525 int fil_cnt; 4526 efdr_t *fil_ptr; 4527 efdr_t *fil_end; 4528 4529 if (file_link->next == NULL) 4530 fil_cnt = file_desc.objects_last_page; 4531 else 4532 fil_cnt = file_desc.objects_per_page; 4533 fil_ptr = file_link->datum->file; 4534 fil_end = fil_ptr + fil_cnt; 4535 for (; fil_ptr < fil_end; fil_ptr++) 4536 { 4537 if ((bfd_size_type)(*bufend - fdr_out) < external_fdr_size) 4538 fdr_out = ecoff_add_bytes (buf, bufend, fdr_out, 4539 external_fdr_size); 4540 (*swap_fdr_out) (stdoutput, &fil_ptr->fdr, fdr_out); 4541 fdr_out += external_fdr_size; 4542 ++ifile; 4543 } 4544 } 4545 4546 return offset + ifile * external_fdr_size; 4547 } 4548 4549 /* Set up the external symbols. These are supposed to be handled by 4550 the backend. This routine just gets the right information and 4551 calls a backend function to deal with it. */ 4552 4553 static void 4554 ecoff_setup_ext (void) 4555 { 4556 symbolS *sym; 4557 4558 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym)) 4559 { 4560 if (symbol_get_obj (sym)->ecoff_symbol == NULL) 4561 continue; 4562 4563 /* If this is a local symbol, then force the fields to zero. */ 4564 if (! S_IS_EXTERNAL (sym) 4565 && ! S_IS_WEAK (sym) 4566 && S_IS_DEFINED (sym)) 4567 { 4568 struct localsym *lsym; 4569 4570 lsym = symbol_get_obj (sym)->ecoff_symbol; 4571 lsym->ecoff_sym.asym.value = 0; 4572 lsym->ecoff_sym.asym.st = st_Nil; 4573 lsym->ecoff_sym.asym.sc = sc_Nil; 4574 lsym->ecoff_sym.asym.index = indexNil; 4575 } 4576 4577 obj_ecoff_set_ext (sym, &symbol_get_obj (sym)->ecoff_symbol->ecoff_sym); 4578 } 4579 } 4580 4581 /* Build the ECOFF debugging information. */ 4582 4583 unsigned long 4584 ecoff_build_debug (HDRR *hdr, 4585 char **bufp, 4586 const struct ecoff_debug_swap *backend) 4587 { 4588 const bfd_size_type external_pdr_size = backend->external_pdr_size; 4589 tag_t *ptag; 4590 tag_t *ptag_next; 4591 efdr_t *fil_ptr; 4592 int end_warning; 4593 efdr_t *hold_file_ptr; 4594 proc_t *hold_proc_ptr; 4595 symbolS *sym; 4596 char *buf; 4597 char *bufend; 4598 unsigned long offset; 4599 4600 /* Make sure we have a file. */ 4601 if (first_file == NULL) 4602 add_file (NULL, 0, 1); 4603 4604 /* Handle any top level tags. */ 4605 for (ptag = top_tag_head->first_tag; 4606 ptag != NULL; 4607 ptag = ptag_next) 4608 { 4609 if (ptag->forward_ref != NULL) 4610 add_unknown_tag (ptag); 4611 4612 ptag_next = ptag->same_block; 4613 ptag->hash_ptr->tag_ptr = ptag->same_name; 4614 free_tag (ptag); 4615 } 4616 4617 free_thead (top_tag_head); 4618 4619 /* Look through the symbols. Add debugging information for each 4620 symbol that has not already received it. */ 4621 hold_file_ptr = cur_file_ptr; 4622 hold_proc_ptr = cur_proc_ptr; 4623 cur_proc_ptr = NULL; 4624 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym)) 4625 { 4626 if (symbol_get_obj (sym)->ecoff_symbol != NULL 4627 || symbol_get_obj (sym)->ecoff_file == NULL 4628 || (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0) 4629 continue; 4630 4631 cur_file_ptr = symbol_get_obj (sym)->ecoff_file; 4632 add_ecoff_symbol (NULL, st_Nil, sc_Nil, sym, 4633 0, S_GET_VALUE (sym), indexNil); 4634 } 4635 cur_proc_ptr = hold_proc_ptr; 4636 cur_file_ptr = hold_file_ptr; 4637 4638 /* Output an ending symbol for all the files. We have to do this 4639 here for the last file, so we may as well do it for all of the 4640 files. */ 4641 end_warning = 0; 4642 for (fil_ptr = first_file; 4643 fil_ptr != NULL; 4644 fil_ptr = fil_ptr->next_file) 4645 { 4646 cur_file_ptr = fil_ptr; 4647 while (cur_file_ptr->cur_scope != NULL 4648 && cur_file_ptr->cur_scope->prev != NULL) 4649 { 4650 cur_file_ptr->cur_scope = cur_file_ptr->cur_scope->prev; 4651 if (! end_warning && ! cur_file_ptr->fake) 4652 { 4653 as_warn (_("missing .end or .bend at end of file")); 4654 end_warning = 1; 4655 } 4656 } 4657 if (cur_file_ptr->cur_scope != NULL) 4658 (void) add_ecoff_symbol (NULL, st_End, sc_Text, NULL, 0, 0, 0); 4659 } 4660 4661 /* Build the symbolic information. */ 4662 offset = 0; 4663 buf = XNEWVEC (char, PAGE_SIZE); 4664 bufend = buf + PAGE_SIZE; 4665 4666 /* Build the line number information. */ 4667 hdr->cbLineOffset = offset; 4668 offset = ecoff_build_lineno (backend, &buf, &bufend, offset, 4669 &hdr->ilineMax); 4670 hdr->cbLine = offset - hdr->cbLineOffset; 4671 4672 /* We don't use dense numbers at all. */ 4673 hdr->idnMax = 0; 4674 hdr->cbDnOffset = 0; 4675 4676 /* We can't build the PDR table until we have built the symbols, 4677 because a PDR contains a symbol index. However, we set aside 4678 space at this point. */ 4679 hdr->ipdMax = proc_cnt; 4680 hdr->cbPdOffset = offset; 4681 if ((bfd_size_type)(bufend - (buf + offset)) < proc_cnt * external_pdr_size) 4682 (void) ecoff_add_bytes (&buf, &bufend, buf + offset, 4683 proc_cnt * external_pdr_size); 4684 offset += proc_cnt * external_pdr_size; 4685 4686 /* Build the local symbols. */ 4687 hdr->cbSymOffset = offset; 4688 offset = ecoff_build_symbols (backend, &buf, &bufend, offset); 4689 hdr->isymMax = (offset - hdr->cbSymOffset) / backend->external_sym_size; 4690 4691 /* Building the symbols initializes the symbol index in the PDR's. 4692 Now we can swap out the PDR's. */ 4693 (void) ecoff_build_procs (backend, &buf, &bufend, hdr->cbPdOffset); 4694 4695 /* We don't use optimization symbols. */ 4696 hdr->ioptMax = 0; 4697 hdr->cbOptOffset = 0; 4698 4699 /* Swap out the auxiliary type information. */ 4700 hdr->cbAuxOffset = offset; 4701 offset = ecoff_build_aux (backend, &buf, &bufend, offset); 4702 hdr->iauxMax = (offset - hdr->cbAuxOffset) / sizeof (union aux_ext); 4703 4704 /* Copy out the local strings. */ 4705 hdr->cbSsOffset = offset; 4706 offset = ecoff_build_ss (backend, &buf, &bufend, offset); 4707 hdr->issMax = offset - hdr->cbSsOffset; 4708 4709 /* We don't use relative file descriptors. */ 4710 hdr->crfd = 0; 4711 hdr->cbRfdOffset = 0; 4712 4713 /* Swap out the file descriptors. */ 4714 hdr->cbFdOffset = offset; 4715 offset = ecoff_build_fdr (backend, &buf, &bufend, offset); 4716 hdr->ifdMax = (offset - hdr->cbFdOffset) / backend->external_fdr_size; 4717 4718 /* Set up the external symbols, which are handled by the BFD back 4719 end. */ 4720 hdr->issExtMax = 0; 4721 hdr->cbSsExtOffset = 0; 4722 hdr->iextMax = 0; 4723 hdr->cbExtOffset = 0; 4724 ecoff_setup_ext (); 4725 4726 know ((offset & (backend->debug_align - 1)) == 0); 4727 4728 /* FIXME: This value should be determined from the .verstamp directive, 4729 with reasonable defaults in config files. */ 4730 #ifdef TC_ALPHA 4731 hdr->vstamp = 0x030b; 4732 #else 4733 hdr->vstamp = 0x020b; 4734 #endif 4735 4736 *bufp = buf; 4737 return offset; 4738 } 4739 4740 /* Allocate a cluster of pages. */ 4742 4743 #ifndef MALLOC_CHECK 4744 4745 static page_type * 4746 allocate_cluster (unsigned long npages) 4747 { 4748 page_type *value = xmalloc (npages * PAGE_USIZE); 4749 4750 #ifdef ECOFF_DEBUG 4751 if (debug > 3) 4752 fprintf (stderr, "\talloc\tnpages = %d, value = 0x%.8x\n", npages, value); 4753 #endif 4754 4755 memset (value, 0, npages * PAGE_USIZE); 4756 4757 return value; 4758 } 4759 4760 static page_type *cluster_ptr = NULL; 4761 static unsigned long pages_left = 0; 4762 4763 #endif /* MALLOC_CHECK */ 4764 4765 /* Allocate one page (which is initialized to 0). */ 4766 4767 static page_type * 4768 allocate_page (void) 4769 { 4770 #ifndef MALLOC_CHECK 4771 4772 if (pages_left == 0) 4773 { 4774 pages_left = MAX_CLUSTER_PAGES; 4775 cluster_ptr = allocate_cluster (pages_left); 4776 } 4777 4778 pages_left--; 4779 return cluster_ptr++; 4780 4781 #else /* MALLOC_CHECK */ 4782 4783 page_type *ptr; 4784 4785 ptr = xmalloc (PAGE_USIZE); 4786 memset (ptr, 0, PAGE_USIZE); 4787 return ptr; 4788 4789 #endif /* MALLOC_CHECK */ 4790 } 4791 4792 /* Allocate scoping information. */ 4794 4795 static scope_t * 4796 allocate_scope (void) 4797 { 4798 scope_t *ptr; 4799 4800 #ifndef MALLOC_CHECK 4801 4802 ptr = alloc_counts[alloc_type_scope].free_list.f_scope; 4803 if (ptr != NULL) 4804 alloc_counts[alloc_type_scope].free_list.f_scope = ptr->free; 4805 else 4806 { 4807 int unallocated = alloc_counts[alloc_type_scope].unallocated; 4808 page_type *cur_page = alloc_counts[alloc_type_scope].cur_page; 4809 4810 if (unallocated == 0) 4811 { 4812 unallocated = PAGE_SIZE / sizeof (scope_t); 4813 alloc_counts[alloc_type_scope].cur_page = cur_page = allocate_page (); 4814 alloc_counts[alloc_type_scope].total_pages++; 4815 } 4816 4817 ptr = &cur_page->scope[--unallocated]; 4818 alloc_counts[alloc_type_scope].unallocated = unallocated; 4819 } 4820 4821 #else 4822 4823 ptr = XNEW (scope_t); 4824 4825 #endif 4826 4827 alloc_counts[alloc_type_scope].total_alloc++; 4828 memset (ptr, 0, sizeof (*ptr)); 4829 return ptr; 4830 } 4831 4832 /* Free scoping information. */ 4833 4834 static void 4835 free_scope (scope_t *ptr) 4836 { 4837 alloc_counts[alloc_type_scope].total_free++; 4838 4839 #ifndef MALLOC_CHECK 4840 ptr->free = alloc_counts[alloc_type_scope].free_list.f_scope; 4841 alloc_counts[alloc_type_scope].free_list.f_scope = ptr; 4842 #else 4843 free (ptr); 4844 #endif 4845 } 4846 4847 /* Allocate links for pages in a virtual array. */ 4849 4850 static vlinks_t * 4851 allocate_vlinks (void) 4852 { 4853 vlinks_t *ptr; 4854 4855 #ifndef MALLOC_CHECK 4856 4857 int unallocated = alloc_counts[alloc_type_vlinks].unallocated; 4858 page_type *cur_page = alloc_counts[alloc_type_vlinks].cur_page; 4859 4860 if (unallocated == 0) 4861 { 4862 unallocated = PAGE_SIZE / sizeof (vlinks_t); 4863 alloc_counts[alloc_type_vlinks].cur_page = cur_page = allocate_page (); 4864 alloc_counts[alloc_type_vlinks].total_pages++; 4865 } 4866 4867 ptr = &cur_page->vlinks[--unallocated]; 4868 alloc_counts[alloc_type_vlinks].unallocated = unallocated; 4869 4870 #else 4871 4872 ptr = XNEW (vlinks_t); 4873 4874 #endif 4875 4876 alloc_counts[alloc_type_vlinks].total_alloc++; 4877 memset (ptr, 0, sizeof (*ptr)); 4878 return ptr; 4879 } 4880 4881 /* Allocate string hash buckets. */ 4883 4884 static shash_t * 4885 allocate_shash (void) 4886 { 4887 shash_t *ptr; 4888 4889 #ifndef MALLOC_CHECK 4890 4891 int unallocated = alloc_counts[alloc_type_shash].unallocated; 4892 page_type *cur_page = alloc_counts[alloc_type_shash].cur_page; 4893 4894 if (unallocated == 0) 4895 { 4896 unallocated = PAGE_SIZE / sizeof (shash_t); 4897 alloc_counts[alloc_type_shash].cur_page = cur_page = allocate_page (); 4898 alloc_counts[alloc_type_shash].total_pages++; 4899 } 4900 4901 ptr = &cur_page->shash[--unallocated]; 4902 alloc_counts[alloc_type_shash].unallocated = unallocated; 4903 4904 #else 4905 4906 ptr = XNEW (shash_t); 4907 4908 #endif 4909 4910 alloc_counts[alloc_type_shash].total_alloc++; 4911 memset (ptr, 0, sizeof (*ptr)); 4912 return ptr; 4913 } 4914 4915 /* Allocate type hash buckets. */ 4917 4918 static thash_t * 4919 allocate_thash (void) 4920 { 4921 thash_t *ptr; 4922 4923 #ifndef MALLOC_CHECK 4924 4925 int unallocated = alloc_counts[alloc_type_thash].unallocated; 4926 page_type *cur_page = alloc_counts[alloc_type_thash].cur_page; 4927 4928 if (unallocated == 0) 4929 { 4930 unallocated = PAGE_SIZE / sizeof (thash_t); 4931 alloc_counts[alloc_type_thash].cur_page = cur_page = allocate_page (); 4932 alloc_counts[alloc_type_thash].total_pages++; 4933 } 4934 4935 ptr = &cur_page->thash[--unallocated]; 4936 alloc_counts[alloc_type_thash].unallocated = unallocated; 4937 4938 #else 4939 4940 ptr = XNEW (thash_t); 4941 4942 #endif 4943 4944 alloc_counts[alloc_type_thash].total_alloc++; 4945 memset (ptr, 0, sizeof (*ptr)); 4946 return ptr; 4947 } 4948 4949 /* Allocate structure, union, or enum tag information. */ 4951 4952 static tag_t * 4953 allocate_tag (void) 4954 { 4955 tag_t *ptr; 4956 4957 #ifndef MALLOC_CHECK 4958 4959 ptr = alloc_counts[alloc_type_tag].free_list.f_tag; 4960 if (ptr != NULL) 4961 alloc_counts[alloc_type_tag].free_list.f_tag = ptr->free; 4962 else 4963 { 4964 int unallocated = alloc_counts[alloc_type_tag].unallocated; 4965 page_type *cur_page = alloc_counts[alloc_type_tag].cur_page; 4966 4967 if (unallocated == 0) 4968 { 4969 unallocated = PAGE_SIZE / sizeof (tag_t); 4970 alloc_counts[alloc_type_tag].cur_page = cur_page = allocate_page (); 4971 alloc_counts[alloc_type_tag].total_pages++; 4972 } 4973 4974 ptr = &cur_page->tag[--unallocated]; 4975 alloc_counts[alloc_type_tag].unallocated = unallocated; 4976 } 4977 4978 #else 4979 4980 ptr = XNEW (tag_t); 4981 4982 #endif 4983 4984 alloc_counts[alloc_type_tag].total_alloc++; 4985 memset (ptr, 0, sizeof (*ptr)); 4986 return ptr; 4987 } 4988 4989 /* Free scoping information. */ 4990 4991 static void 4992 free_tag (tag_t *ptr) 4993 { 4994 alloc_counts[alloc_type_tag].total_free++; 4995 4996 #ifndef MALLOC_CHECK 4997 ptr->free = alloc_counts[alloc_type_tag].free_list.f_tag; 4998 alloc_counts[alloc_type_tag].free_list.f_tag = ptr; 4999 #else 5000 free (ptr); 5001 #endif 5002 } 5003 5004 /* Allocate forward reference to a yet unknown tag. */ 5006 5007 static forward_t * 5008 allocate_forward (void) 5009 { 5010 forward_t *ptr; 5011 5012 #ifndef MALLOC_CHECK 5013 5014 int unallocated = alloc_counts[alloc_type_forward].unallocated; 5015 page_type *cur_page = alloc_counts[alloc_type_forward].cur_page; 5016 5017 if (unallocated == 0) 5018 { 5019 unallocated = PAGE_SIZE / sizeof (forward_t); 5020 alloc_counts[alloc_type_forward].cur_page = cur_page = allocate_page (); 5021 alloc_counts[alloc_type_forward].total_pages++; 5022 } 5023 5024 ptr = &cur_page->forward[--unallocated]; 5025 alloc_counts[alloc_type_forward].unallocated = unallocated; 5026 5027 #else 5028 5029 ptr = XNEW (forward_t); 5030 5031 #endif 5032 5033 alloc_counts[alloc_type_forward].total_alloc++; 5034 memset (ptr, 0, sizeof (*ptr)); 5035 return ptr; 5036 } 5037 5038 /* Allocate head of type hash list. */ 5040 5041 static thead_t * 5042 allocate_thead (void) 5043 { 5044 thead_t *ptr; 5045 5046 #ifndef MALLOC_CHECK 5047 5048 ptr = alloc_counts[alloc_type_thead].free_list.f_thead; 5049 if (ptr != NULL) 5050 alloc_counts[alloc_type_thead].free_list.f_thead = ptr->free; 5051 else 5052 { 5053 int unallocated = alloc_counts[alloc_type_thead].unallocated; 5054 page_type *cur_page = alloc_counts[alloc_type_thead].cur_page; 5055 5056 if (unallocated == 0) 5057 { 5058 unallocated = PAGE_SIZE / sizeof (thead_t); 5059 alloc_counts[alloc_type_thead].cur_page = cur_page = allocate_page (); 5060 alloc_counts[alloc_type_thead].total_pages++; 5061 } 5062 5063 ptr = &cur_page->thead[--unallocated]; 5064 alloc_counts[alloc_type_thead].unallocated = unallocated; 5065 } 5066 5067 #else 5068 5069 ptr = XNEW (thead_t); 5070 5071 #endif 5072 5073 alloc_counts[alloc_type_thead].total_alloc++; 5074 memset (ptr, 0, sizeof (*ptr)); 5075 return ptr; 5076 } 5077 5078 /* Free scoping information. */ 5079 5080 static void 5081 free_thead (thead_t *ptr) 5082 { 5083 alloc_counts[alloc_type_thead].total_free++; 5084 5085 #ifndef MALLOC_CHECK 5086 ptr->free = alloc_counts[alloc_type_thead].free_list.f_thead; 5087 alloc_counts[alloc_type_thead].free_list.f_thead = ptr; 5088 #else 5089 free (ptr); 5090 #endif 5091 } 5092 5093 static lineno_list_t * 5095 allocate_lineno_list (void) 5096 { 5097 lineno_list_t *ptr; 5098 5099 #ifndef MALLOC_CHECK 5100 5101 int unallocated = alloc_counts[alloc_type_lineno].unallocated; 5102 page_type *cur_page = alloc_counts[alloc_type_lineno].cur_page; 5103 5104 if (unallocated == 0) 5105 { 5106 unallocated = PAGE_SIZE / sizeof (lineno_list_t); 5107 alloc_counts[alloc_type_lineno].cur_page = cur_page = allocate_page (); 5108 alloc_counts[alloc_type_lineno].total_pages++; 5109 } 5110 5111 ptr = &cur_page->lineno[--unallocated]; 5112 alloc_counts[alloc_type_lineno].unallocated = unallocated; 5113 5114 #else 5115 5116 ptr = XNEW (lineno_list_t); 5117 5118 #endif 5119 5120 alloc_counts[alloc_type_lineno].total_alloc++; 5121 memset (ptr, 0, sizeof (*ptr)); 5122 return ptr; 5123 } 5124 5125 void 5126 ecoff_set_gp_prolog_size (int sz) 5127 { 5128 if (cur_proc_ptr == 0) 5129 return; 5130 5131 cur_proc_ptr->pdr.gp_prologue = sz; 5132 if (cur_proc_ptr->pdr.gp_prologue != sz) 5133 { 5134 as_warn (_("GP prologue size exceeds field size, using 0 instead")); 5135 cur_proc_ptr->pdr.gp_prologue = 0; 5136 } 5137 5138 cur_proc_ptr->pdr.gp_used = 1; 5139 } 5140 5141 int 5142 ecoff_no_current_file (void) 5143 { 5144 return cur_file_ptr == NULL; 5145 } 5146 5147 void 5148 ecoff_generate_asm_lineno (void) 5149 { 5150 unsigned int lineno; 5151 const char *filename; 5152 lineno_list_t *list; 5153 5154 filename = as_where (&lineno); 5155 5156 if (current_stabs_filename == NULL 5157 || filename_cmp (current_stabs_filename, filename)) 5158 add_file (filename, 0, 1); 5159 5160 list = allocate_lineno_list (); 5161 5162 list->next = NULL; 5163 list->file = cur_file_ptr; 5164 list->proc = cur_proc_ptr; 5165 list->frag = frag_now; 5166 list->paddr = frag_now_fix (); 5167 list->lineno = lineno; 5168 5169 /* We don't want to merge files which have line numbers. */ 5170 cur_file_ptr->fdr.fMerge = 0; 5171 5172 /* A .loc directive will sometimes appear before a .ent directive, 5173 which means that cur_proc_ptr will be NULL here. Arrange to 5174 patch this up. */ 5175 if (cur_proc_ptr == NULL) 5176 { 5177 lineno_list_t **pl; 5178 5179 pl = &noproc_lineno; 5180 while (*pl != NULL) 5181 pl = &(*pl)->next; 5182 *pl = list; 5183 } 5184 else 5185 { 5186 last_lineno = list; 5187 *last_lineno_ptr = list; 5188 last_lineno_ptr = &list->next; 5189 } 5190 } 5191 5192 #else 5193 5194 void 5195 ecoff_generate_asm_lineno (void) 5196 { 5197 } 5198 5199 #endif /* ECOFF_DEBUGGING */ 5200
Indexes created Sun Mar 15 00:25:29 UTC 2026