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