1 //===- LDFileFormat.h -----------------------------------------------------===// 2 // 3 // The MCLinker Project 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 #ifndef MCLD_ELF_FILE_FORMAT_H 10 #define MCLD_ELF_FILE_FORMAT_H 11 #ifdef ENABLE_UNITTEST 12 #include <gtest.h> 13 #endif 14 #include <mcld/LD/LDFileFormat.h> 15 #include <mcld/LD/LDSection.h> 16 17 namespace mcld { 18 19 class ObjectBuilder; 20 21 /** \class ELFFileFormat 22 * \brief ELFFileFormat describes the common file formats in ELF. 23 * LDFileFormats control the formats of the output file. 24 * 25 * @ref "Object Files," Ch. 4, in System V Application Binary Interface, 26 * Fourth Edition. 27 * 28 * @ref "Object Format," Ch. 10, in ISO/IEC 23360 Part 1:2010(E), Linux 29 * Standard Base Core Specification 4.1. 30 */ 31 class ELFFileFormat : public LDFileFormat 32 { 33 private: 34 /// initObjectFormat - initialize sections that are dependent on object 35 /// formats. (executable, shared objects or relocatable objects). 36 virtual void 37 initObjectFormat(ObjectBuilder& pBuilder, unsigned int pBitClass) = 0; 38 39 public: 40 ELFFileFormat(); 41 42 void initStdSections(ObjectBuilder& pBuilder, unsigned int pBitClass); 43 44 // ----- capacity ----- // 45 /// @ref Special Sections, Ch. 4.17, System V ABI, 4th edition. hasNULLSection()46 bool hasNULLSection() const 47 { return (NULL != f_pNULLSection) && (0 != f_pNULLSection->size()); } 48 hasGOT()49 bool hasGOT() const 50 { return (NULL != f_pGOT) && (0 != f_pGOT->size()); } 51 hasPLT()52 bool hasPLT() const 53 { return (NULL != f_pPLT) && (0 != f_pPLT->size()); } 54 hasRelDyn()55 bool hasRelDyn() const 56 { return (NULL != f_pRelDyn) && (0 != f_pRelDyn->size()); } 57 hasRelPlt()58 bool hasRelPlt() const 59 { return (NULL != f_pRelPlt) && (0 != f_pRelPlt->size()); } 60 hasRelaDyn()61 bool hasRelaDyn() const 62 { return (NULL != f_pRelaDyn) && (0 != f_pRelaDyn->size()); } 63 hasRelaPlt()64 bool hasRelaPlt() const 65 { return (NULL != f_pRelaPlt) && (0 != f_pRelaPlt->size()); } 66 67 /// @ref 10.3.1.1, ISO/IEC 23360, Part 1:2010(E), p. 21. hasComment()68 bool hasComment() const 69 { return (NULL != f_pComment) && (0 != f_pComment->size()); } 70 hasData1()71 bool hasData1() const 72 { return (NULL != f_pData1) && (0 != f_pData1->size()); } 73 hasDebug()74 bool hasDebug() const 75 { return (NULL != f_pDebug) && (0 != f_pDebug->size()); } 76 hasDynamic()77 bool hasDynamic() const 78 { return (NULL != f_pDynamic) && (0 != f_pDynamic->size()); } 79 hasDynStrTab()80 bool hasDynStrTab() const 81 { return (NULL != f_pDynStrTab) && (0 != f_pDynStrTab->size()); } 82 hasDynSymTab()83 bool hasDynSymTab() const 84 { return (NULL != f_pDynSymTab) && (0 != f_pDynSymTab->size()); } 85 hasFini()86 bool hasFini() const 87 { return (NULL != f_pFini) && (0 != f_pFini->size()); } 88 hasFiniArray()89 bool hasFiniArray() const 90 { return (NULL != f_pFiniArray) && (0 != f_pFiniArray->size()); } 91 hasHashTab()92 bool hasHashTab() const 93 { return (NULL != f_pHashTab) && (0 != f_pHashTab->size()); } 94 hasInit()95 bool hasInit() const 96 { return (NULL != f_pInit) && (0 != f_pInit->size()); } 97 hasInitArray()98 bool hasInitArray() const 99 { return (NULL != f_pInitArray) && (0 != f_pInitArray->size()); } 100 hasInterp()101 bool hasInterp() const 102 { return (NULL != f_pInterp) && (0 != f_pInterp->size()); } 103 hasLine()104 bool hasLine() const 105 { return (NULL != f_pLine) && (0 != f_pLine->size()); } 106 hasNote()107 bool hasNote() const 108 { return (NULL != f_pNote) && (0 != f_pNote->size()); } 109 hasPreInitArray()110 bool hasPreInitArray() const 111 { return (NULL != f_pPreInitArray) && (0 != f_pPreInitArray->size()); } 112 hasROData1()113 bool hasROData1() const 114 { return (NULL != f_pROData1) && (0 != f_pROData1->size()); } 115 hasShStrTab()116 bool hasShStrTab() const 117 { return (NULL != f_pShStrTab) && (0 != f_pShStrTab->size()); } 118 hasStrTab()119 bool hasStrTab() const 120 { return (NULL != f_pStrTab) && (0 != f_pStrTab->size()); } 121 hasSymTab()122 bool hasSymTab() const 123 { return (NULL != f_pSymTab) && (0 != f_pSymTab->size()); } 124 hasTBSS()125 bool hasTBSS() const 126 { return (NULL != f_pTBSS) && (0 != f_pTBSS->size()); } 127 hasTData()128 bool hasTData() const 129 { return (NULL != f_pTData) && (0 != f_pTData->size()); } 130 131 /// @ref 10.3.1.2, ISO/IEC 23360, Part 1:2010(E), p. 24. hasCtors()132 bool hasCtors() const 133 { return (NULL != f_pCtors) && (0 != f_pCtors->size()); } 134 hasDataRelRo()135 bool hasDataRelRo() const 136 { return (NULL != f_pDataRelRo) && (0 != f_pDataRelRo->size()); } 137 hasDtors()138 bool hasDtors() const 139 { return (NULL != f_pDtors) && (0 != f_pDtors->size()); } 140 hasEhFrame()141 bool hasEhFrame() const 142 { return (NULL != f_pEhFrame) && (0 != f_pEhFrame->size()); } 143 hasEhFrameHdr()144 bool hasEhFrameHdr() const 145 { return (NULL != f_pEhFrameHdr) && (0 != f_pEhFrameHdr->size()); } 146 hasGCCExceptTable()147 bool hasGCCExceptTable() const 148 { return (NULL != f_pGCCExceptTable) && (0 != f_pGCCExceptTable->size()); } 149 hasGNUVersion()150 bool hasGNUVersion() const 151 { return (NULL != f_pGNUVersion) && (0 != f_pGNUVersion->size()); } 152 hasGNUVersionD()153 bool hasGNUVersionD() const 154 { return (NULL != f_pGNUVersionD) && (0 != f_pGNUVersionD->size()); } 155 hasGNUVersionR()156 bool hasGNUVersionR() const 157 { return (NULL != f_pGNUVersionR) && (0 != f_pGNUVersionR->size()); } 158 hasGOTPLT()159 bool hasGOTPLT() const 160 { return (NULL != f_pGOTPLT) && (0 != f_pGOTPLT->size()); } 161 hasJCR()162 bool hasJCR() const 163 { return (NULL != f_pJCR) && (0 != f_pJCR->size()); } 164 hasNoteABITag()165 bool hasNoteABITag() const 166 { return (NULL != f_pNoteABITag) && (0 != f_pNoteABITag->size()); } 167 hasStab()168 bool hasStab() const 169 { return (NULL != f_pStab) && (0 != f_pStab->size()); } 170 hasStabStr()171 bool hasStabStr() const 172 { return (NULL != f_pStabStr) && (0 != f_pStabStr->size()); } 173 hasStack()174 bool hasStack() const 175 { return (NULL != f_pStack) && (0 != f_pStack->size()); } 176 hasStackNote()177 bool hasStackNote() const 178 { return (NULL != f_pStackNote); } 179 hasDataRelRoLocal()180 bool hasDataRelRoLocal() const 181 { return (NULL != f_pDataRelRoLocal) && (0 != f_pDataRelRoLocal->size()); } 182 hasGNUHashTab()183 bool hasGNUHashTab() const 184 { return (NULL != f_pGNUHashTab) && (0 != f_pGNUHashTab->size()); } 185 186 // ----- access functions ----- // 187 /// @ref Special Sections, Ch. 4.17, System V ABI, 4th edition. getNULLSection()188 LDSection& getNULLSection() { 189 assert(NULL != f_pNULLSection); 190 return *f_pNULLSection; 191 } 192 getNULLSection()193 const LDSection& getNULLSection() const { 194 assert(NULL != f_pNULLSection); 195 return *f_pNULLSection; 196 } 197 getGOT()198 LDSection& getGOT() { 199 assert(NULL != f_pGOT); 200 return *f_pGOT; 201 } 202 getGOT()203 const LDSection& getGOT() const { 204 assert(NULL != f_pGOT); 205 return *f_pGOT; 206 } 207 getPLT()208 LDSection& getPLT() { 209 assert(NULL != f_pPLT); 210 return *f_pPLT; 211 } 212 getPLT()213 const LDSection& getPLT() const { 214 assert(NULL != f_pPLT); 215 return *f_pPLT; 216 } 217 getRelDyn()218 LDSection& getRelDyn() { 219 assert(NULL != f_pRelDyn); 220 return *f_pRelDyn; 221 } 222 getRelDyn()223 const LDSection& getRelDyn() const { 224 assert(NULL != f_pRelDyn); 225 return *f_pRelDyn; 226 } 227 getRelPlt()228 LDSection& getRelPlt() { 229 assert(NULL != f_pRelPlt); 230 return *f_pRelPlt; 231 } 232 getRelPlt()233 const LDSection& getRelPlt() const { 234 assert(NULL != f_pRelPlt); 235 return *f_pRelPlt; 236 } 237 getRelaDyn()238 LDSection& getRelaDyn() { 239 assert(NULL != f_pRelaDyn); 240 return *f_pRelaDyn; 241 } 242 getRelaDyn()243 const LDSection& getRelaDyn() const { 244 assert(NULL != f_pRelaDyn); 245 return *f_pRelaDyn; 246 } 247 getRelaPlt()248 LDSection& getRelaPlt() { 249 assert(NULL != f_pRelaPlt); 250 return *f_pRelaPlt; 251 } 252 getRelaPlt()253 const LDSection& getRelaPlt() const { 254 assert(NULL != f_pRelaPlt); 255 return *f_pRelaPlt; 256 } 257 getComment()258 LDSection& getComment() { 259 assert(NULL != f_pComment); 260 return *f_pComment; 261 } 262 263 /// @ref 10.3.1.1, ISO/IEC 23360, Part 1:2010(E), p. 21. getComment()264 const LDSection& getComment() const { 265 assert(NULL != f_pComment); 266 return *f_pComment; 267 } 268 getData1()269 LDSection& getData1() { 270 assert(NULL != f_pData1); 271 return *f_pData1; 272 } 273 getData1()274 const LDSection& getData1() const { 275 assert(NULL != f_pData1); 276 return *f_pData1; 277 } 278 getDebug()279 LDSection& getDebug() { 280 assert(NULL != f_pDebug); 281 return *f_pDebug; 282 } 283 getDebug()284 const LDSection& getDebug() const { 285 assert(NULL != f_pDebug); 286 return *f_pDebug; 287 } 288 getDynamic()289 LDSection& getDynamic() { 290 assert(NULL != f_pDynamic); 291 return *f_pDynamic; 292 } 293 getDynamic()294 const LDSection& getDynamic() const { 295 assert(NULL != f_pDynamic); 296 return *f_pDynamic; 297 } 298 getDynStrTab()299 LDSection& getDynStrTab() { 300 assert(NULL != f_pDynStrTab); 301 return *f_pDynStrTab; 302 } 303 getDynStrTab()304 const LDSection& getDynStrTab() const { 305 assert(NULL != f_pDynStrTab); 306 return *f_pDynStrTab; 307 } 308 getDynSymTab()309 LDSection& getDynSymTab() { 310 assert(NULL != f_pDynSymTab); 311 return *f_pDynSymTab; 312 } 313 getDynSymTab()314 const LDSection& getDynSymTab() const { 315 assert(NULL != f_pDynSymTab); 316 return *f_pDynSymTab; 317 } 318 getFini()319 LDSection& getFini() { 320 assert(NULL != f_pFini); 321 return *f_pFini; 322 } 323 getFini()324 const LDSection& getFini() const { 325 assert(NULL != f_pFini); 326 return *f_pFini; 327 } 328 getFiniArray()329 LDSection& getFiniArray() { 330 assert(NULL != f_pFiniArray); 331 return *f_pFiniArray; 332 } 333 getFiniArray()334 const LDSection& getFiniArray() const { 335 assert(NULL != f_pFiniArray); 336 return *f_pFiniArray; 337 } 338 getHashTab()339 LDSection& getHashTab() { 340 assert(NULL != f_pHashTab); 341 return *f_pHashTab; 342 } 343 getHashTab()344 const LDSection& getHashTab() const { 345 assert(NULL != f_pHashTab); 346 return *f_pHashTab; 347 } 348 getInit()349 LDSection& getInit() { 350 assert(NULL != f_pInit); 351 return *f_pInit; 352 } 353 getInit()354 const LDSection& getInit() const { 355 assert(NULL != f_pInit); 356 return *f_pInit; 357 } 358 getInitArray()359 LDSection& getInitArray() { 360 assert(NULL != f_pInitArray); 361 return *f_pInitArray; 362 } 363 getInitArray()364 const LDSection& getInitArray() const { 365 assert(NULL != f_pInitArray); 366 return *f_pInitArray; 367 } 368 getInterp()369 LDSection& getInterp() { 370 assert(NULL != f_pInterp); 371 return *f_pInterp; 372 } 373 getInterp()374 const LDSection& getInterp() const { 375 assert(NULL != f_pInterp); 376 return *f_pInterp; 377 } 378 getLine()379 LDSection& getLine() { 380 assert(NULL != f_pLine); 381 return *f_pLine; 382 } 383 getLine()384 const LDSection& getLine() const { 385 assert(NULL != f_pLine); 386 return *f_pLine; 387 } 388 getNote()389 LDSection& getNote() { 390 assert(NULL != f_pNote); 391 return *f_pNote; 392 } 393 getNote()394 const LDSection& getNote() const { 395 assert(NULL != f_pNote); 396 return *f_pNote; 397 } 398 getPreInitArray()399 LDSection& getPreInitArray() { 400 assert(NULL != f_pPreInitArray); 401 return *f_pPreInitArray; 402 } 403 getPreInitArray()404 const LDSection& getPreInitArray() const { 405 assert(NULL != f_pPreInitArray); 406 return *f_pPreInitArray; 407 } 408 getROData1()409 LDSection& getROData1() { 410 assert(NULL != f_pROData1); 411 return *f_pROData1; 412 } 413 getROData1()414 const LDSection& getROData1() const { 415 assert(NULL != f_pROData1); 416 return *f_pROData1; 417 } 418 getShStrTab()419 LDSection& getShStrTab() { 420 assert(NULL != f_pShStrTab); 421 return *f_pShStrTab; 422 } 423 getShStrTab()424 const LDSection& getShStrTab() const { 425 assert(NULL != f_pShStrTab); 426 return *f_pShStrTab; 427 } 428 getStrTab()429 LDSection& getStrTab() { 430 assert(NULL != f_pStrTab); 431 return *f_pStrTab; 432 } 433 getStrTab()434 const LDSection& getStrTab() const { 435 assert(NULL != f_pStrTab); 436 return *f_pStrTab; 437 } 438 getSymTab()439 LDSection& getSymTab() { 440 assert(NULL != f_pSymTab); 441 return *f_pSymTab; 442 } 443 getSymTab()444 const LDSection& getSymTab() const { 445 assert(NULL != f_pSymTab); 446 return *f_pSymTab; 447 } 448 getTBSS()449 LDSection& getTBSS() { 450 assert(NULL != f_pTBSS); 451 return *f_pTBSS; 452 } 453 getTBSS()454 const LDSection& getTBSS() const { 455 assert(NULL != f_pTBSS); 456 return *f_pTBSS; 457 } 458 getTData()459 LDSection& getTData() { 460 assert(NULL != f_pTData); 461 return *f_pTData; 462 } 463 getTData()464 const LDSection& getTData() const { 465 assert(NULL != f_pTData); 466 return *f_pTData; 467 } 468 469 /// @ref 10.3.1.2, ISO/IEC 23360, Part 1:2010(E), p. 24. getCtors()470 LDSection& getCtors() { 471 assert(NULL != f_pCtors); 472 return *f_pCtors; 473 } 474 getCtors()475 const LDSection& getCtors() const { 476 assert(NULL != f_pCtors); 477 return *f_pCtors; 478 } 479 getDataRelRo()480 LDSection& getDataRelRo() { 481 assert(NULL != f_pDataRelRo); 482 return *f_pDataRelRo; 483 } 484 getDataRelRo()485 const LDSection& getDataRelRo() const { 486 assert(NULL != f_pDataRelRo); 487 return *f_pDataRelRo; 488 } 489 getDtors()490 LDSection& getDtors() { 491 assert(NULL != f_pDtors); 492 return *f_pDtors; 493 } 494 getDtors()495 const LDSection& getDtors() const { 496 assert(NULL != f_pDtors); 497 return *f_pDtors; 498 } 499 getEhFrame()500 LDSection& getEhFrame() { 501 assert(NULL != f_pEhFrame); 502 return *f_pEhFrame; 503 } 504 getEhFrame()505 const LDSection& getEhFrame() const { 506 assert(NULL != f_pEhFrame); 507 return *f_pEhFrame; 508 } 509 getEhFrameHdr()510 LDSection& getEhFrameHdr() { 511 assert(NULL != f_pEhFrameHdr); 512 return *f_pEhFrameHdr; 513 } 514 getEhFrameHdr()515 const LDSection& getEhFrameHdr() const { 516 assert(NULL != f_pEhFrameHdr); 517 return *f_pEhFrameHdr; 518 } 519 getGCCExceptTable()520 LDSection& getGCCExceptTable() { 521 assert(NULL != f_pGCCExceptTable); 522 return *f_pGCCExceptTable; 523 } 524 getGCCExceptTable()525 const LDSection& getGCCExceptTable() const { 526 assert(NULL != f_pGCCExceptTable); 527 return *f_pGCCExceptTable; 528 } 529 getGNUVersion()530 LDSection& getGNUVersion() { 531 assert(NULL != f_pGNUVersion); 532 return *f_pGNUVersion; 533 } 534 getGNUVersion()535 const LDSection& getGNUVersion() const { 536 assert(NULL != f_pGNUVersion); 537 return *f_pGNUVersion; 538 } 539 getGNUVersionD()540 LDSection& getGNUVersionD() { 541 assert(NULL != f_pGNUVersionD); 542 return *f_pGNUVersionD; 543 } 544 getGNUVersionD()545 const LDSection& getGNUVersionD() const { 546 assert(NULL != f_pGNUVersionD); 547 return *f_pGNUVersionD; 548 } 549 getGNUVersionR()550 LDSection& getGNUVersionR() { 551 assert(NULL != f_pGNUVersionR); 552 return *f_pGNUVersionR; 553 } 554 getGNUVersionR()555 const LDSection& getGNUVersionR() const { 556 assert(NULL != f_pGNUVersionR); 557 return *f_pGNUVersionR; 558 } 559 getGOTPLT()560 LDSection& getGOTPLT() { 561 assert(NULL != f_pGOTPLT); 562 return *f_pGOTPLT; 563 } 564 getGOTPLT()565 const LDSection& getGOTPLT() const { 566 assert(NULL != f_pGOTPLT); 567 return *f_pGOTPLT; 568 } 569 getJCR()570 LDSection& getJCR() { 571 assert(NULL != f_pJCR); 572 return *f_pJCR; 573 } 574 getJCR()575 const LDSection& getJCR() const { 576 assert(NULL != f_pJCR); 577 return *f_pJCR; 578 } 579 getNoteABITag()580 LDSection& getNoteABITag() { 581 assert(NULL != f_pNoteABITag); 582 return *f_pNoteABITag; 583 } 584 getNoteABITag()585 const LDSection& getNoteABITag() const { 586 assert(NULL != f_pNoteABITag); 587 return *f_pNoteABITag; 588 } 589 getStab()590 LDSection& getStab() { 591 assert(NULL != f_pStab); 592 return *f_pStab; 593 } 594 getStab()595 const LDSection& getStab() const { 596 assert(NULL != f_pStab); 597 return *f_pStab; 598 } 599 getStabStr()600 LDSection& getStabStr() { 601 assert(NULL != f_pStabStr); 602 return *f_pStabStr; 603 } 604 getStabStr()605 const LDSection& getStabStr() const { 606 assert(NULL != f_pStabStr); 607 return *f_pStabStr; 608 } 609 getStack()610 LDSection& getStack() { 611 assert(NULL != f_pStack); 612 return *f_pStack; 613 } 614 getStack()615 const LDSection& getStack() const { 616 assert(NULL != f_pStack); 617 return *f_pStack; 618 } 619 getStackNote()620 LDSection& getStackNote() { 621 assert(NULL != f_pStackNote); 622 return *f_pStackNote; 623 } 624 getStackNote()625 const LDSection& getStackNote() const { 626 assert(NULL != f_pStackNote); 627 return *f_pStackNote; 628 } 629 getDataRelRoLocal()630 LDSection& getDataRelRoLocal() { 631 assert(NULL != f_pDataRelRoLocal); 632 return *f_pDataRelRoLocal; 633 } 634 getDataRelRoLocal()635 const LDSection& getDataRelRoLocal() const { 636 assert(NULL != f_pDataRelRoLocal); 637 return *f_pDataRelRoLocal; 638 } 639 getGNUHashTab()640 LDSection& getGNUHashTab() { 641 assert(NULL != f_pGNUHashTab); 642 return *f_pGNUHashTab; 643 } 644 getGNUHashTab()645 const LDSection& getGNUHashTab() const { 646 assert(NULL != f_pGNUHashTab); 647 return *f_pGNUHashTab; 648 } 649 650 protected: 651 // variable name : ELF 652 /// @ref Special Sections, Ch. 4.17, System V ABI, 4th edition. 653 LDSection* f_pNULLSection; 654 LDSection* f_pGOT; // .got 655 LDSection* f_pPLT; // .plt 656 LDSection* f_pRelDyn; // .rel.dyn 657 LDSection* f_pRelPlt; // .rel.plt 658 LDSection* f_pRelaDyn; // .rela.dyn 659 LDSection* f_pRelaPlt; // .rela.plt 660 661 /// @ref 10.3.1.1, ISO/IEC 23360, Part 1:2010(E), p. 21. 662 LDSection* f_pComment; // .comment 663 LDSection* f_pData1; // .data1 664 LDSection* f_pDebug; // .debug 665 LDSection* f_pDynamic; // .dynamic 666 LDSection* f_pDynStrTab; // .dynstr 667 LDSection* f_pDynSymTab; // .dynsym 668 LDSection* f_pFini; // .fini 669 LDSection* f_pFiniArray; // .fini_array 670 LDSection* f_pHashTab; // .hash 671 LDSection* f_pInit; // .init 672 LDSection* f_pInitArray; // .init_array 673 LDSection* f_pInterp; // .interp 674 LDSection* f_pLine; // .line 675 LDSection* f_pNote; // .note 676 LDSection* f_pPreInitArray; // .preinit_array 677 LDSection* f_pROData1; // .rodata1 678 LDSection* f_pShStrTab; // .shstrtab 679 LDSection* f_pStrTab; // .strtab 680 LDSection* f_pSymTab; // .symtab 681 LDSection* f_pTBSS; // .tbss 682 LDSection* f_pTData; // .tdata 683 684 /// @ref 10.3.1.2, ISO/IEC 23360, Part 1:2010(E), p. 24. 685 LDSection* f_pCtors; // .ctors 686 LDSection* f_pDataRelRo; // .data.rel.ro 687 LDSection* f_pDtors; // .dtors 688 LDSection* f_pEhFrame; // .eh_frame 689 LDSection* f_pEhFrameHdr; // .eh_frame_hdr 690 LDSection* f_pGCCExceptTable; // .gcc_except_table 691 LDSection* f_pGNUVersion; // .gnu.version 692 LDSection* f_pGNUVersionD; // .gnu.version_d 693 LDSection* f_pGNUVersionR; // .gnu.version_r 694 LDSection* f_pGOTPLT; // .got.plt 695 LDSection* f_pJCR; // .jcr 696 LDSection* f_pNoteABITag; // .note.ABI-tag 697 LDSection* f_pStab; // .stab 698 LDSection* f_pStabStr; // .stabstr 699 700 /// practical 701 LDSection* f_pStack; // .stack 702 LDSection* f_pStackNote; // .note.GNU-stack 703 LDSection* f_pDataRelRoLocal; // .data.rel.ro.local 704 LDSection* f_pGNUHashTab; // .gnu.hash 705 }; 706 707 } // namespace of mcld 708 709 #endif 710 711