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