1@section coff backends 2BFD supports a number of different flavours of coff format. 3The major differences between formats are the sizes and 4alignments of fields in structures on disk, and the occasional 5extra field. 6 7Coff in all its varieties is implemented with a few common 8files and a number of implementation specific files. For 9example, the i386 coff format is implemented in the file 10@file{coff-i386.c}. This file @code{#include}s 11@file{coff/i386.h} which defines the external structure of the 12coff format for the i386, and @file{coff/internal.h} which 13defines the internal structure. @file{coff-i386.c} also 14defines the relocations used by the i386 coff format 15@xref{Relocations}. 16 17@subsection Porting to a new version of coff 18The recommended method is to select from the existing 19implementations the version of coff which is most like the one 20you want to use. For example, we'll say that i386 coff is 21the one you select, and that your coff flavour is called foo. 22Copy @file{i386coff.c} to @file{foocoff.c}, copy 23@file{../include/coff/i386.h} to @file{../include/coff/foo.h}, 24and add the lines to @file{targets.c} and @file{Makefile.in} 25so that your new back end is used. Alter the shapes of the 26structures in @file{../include/coff/foo.h} so that they match 27what you need. You will probably also have to add 28@code{#ifdef}s to the code in @file{coff/internal.h} and 29@file{coffcode.h} if your version of coff is too wild. 30 31You can verify that your new BFD backend works quite simply by 32building @file{objdump} from the @file{binutils} directory, 33and making sure that its version of what's going on and your 34host system's idea (assuming it has the pretty standard coff 35dump utility, usually called @code{att-dump} or just 36@code{dump}) are the same. Then clean up your code, and send 37what you've done to Cygnus. Then your stuff will be in the 38next release, and you won't have to keep integrating it. 39 40@subsection How the coff backend works 41 42 43@subsubsection File layout 44The Coff backend is split into generic routines that are 45applicable to any Coff target and routines that are specific 46to a particular target. The target-specific routines are 47further split into ones which are basically the same for all 48Coff targets except that they use the external symbol format 49or use different values for certain constants. 50 51The generic routines are in @file{coffgen.c}. These routines 52work for any Coff target. They use some hooks into the target 53specific code; the hooks are in a @code{bfd_coff_backend_data} 54structure, one of which exists for each target. 55 56The essentially similar target-specific routines are in 57@file{coffcode.h}. This header file includes executable C code. 58The various Coff targets first include the appropriate Coff 59header file, make any special defines that are needed, and 60then include @file{coffcode.h}. 61 62Some of the Coff targets then also have additional routines in 63the target source file itself. 64 65@subsubsection Coff long section names 66In the standard Coff object format, section names are limited to 67the eight bytes available in the @code{s_name} field of the 68@code{SCNHDR} section header structure. The format requires the 69field to be NUL-padded, but not necessarily NUL-terminated, so 70the longest section names permitted are a full eight characters. 71 72The Microsoft PE variants of the Coff object file format add 73an extension to support the use of long section names. This 74extension is defined in section 4 of the Microsoft PE/COFF 75specification (rev 8.1). If a section name is too long to fit 76into the section header's @code{s_name} field, it is instead 77placed into the string table, and the @code{s_name} field is 78filled with a slash ("/") followed by the ASCII decimal 79representation of the offset of the full name relative to the 80string table base. 81 82Note that this implies that the extension can only be used in object 83files, as executables do not contain a string table. The standard 84specifies that long section names from objects emitted into executable 85images are to be truncated. 86 87However, as a GNU extension, BFD can generate executable images 88that contain a string table and long section names. This 89would appear to be technically valid, as the standard only says 90that Coff debugging information is deprecated, not forbidden, 91and in practice it works, although some tools that parse PE files 92expecting the MS standard format may become confused; @file{PEview} is 93one known example. 94 95The functionality is supported in BFD by code implemented under 96the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not 97defined, the format does not support long section names in any way. 98If defined, it is used to initialise a flag, 99@code{_bfd_coff_long_section_names}, and a hook function pointer, 100@code{_bfd_coff_set_long_section_names}, in the Coff backend data 101structure. The flag controls the generation of long section names 102in output BFDs at runtime; if it is false, as it will be by default 103when generating an executable image, long section names are truncated; 104if true, the long section names extension is employed. The hook 105points to a function that allows the value of the flag to be altered 106at runtime, on formats that support long section names at all; on 107other formats it points to a stub that returns an error indication. 108 109With input BFDs, the flag is set according to whether any long section 110names are detected while reading the section headers. For a completely 111new BFD, the flag is set to the default for the target format. This 112information can be used by a client of the BFD library when deciding 113what output format to generate, and means that a BFD that is opened 114for read and subsequently converted to a writeable BFD and modified 115in-place will retain whatever format it had on input. 116 117If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is 118defined to the value "1", then long section names are enabled by 119default; if it is defined to the value zero, they are disabled by 120default (but still accepted in input BFDs). The header @file{coffcode.h} 121defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is 122used in the backends to initialise the backend data structure fields 123appropriately; see the comments for further detail. 124 125@subsubsection Bit twiddling 126Each flavour of coff supported in BFD has its own header file 127describing the external layout of the structures. There is also 128an internal description of the coff layout, in 129@file{coff/internal.h}. A major function of the 130coff backend is swapping the bytes and twiddling the bits to 131translate the external form of the structures into the normal 132internal form. This is all performed in the 133@code{bfd_swap}_@i{thing}_@i{direction} routines. Some 134elements are different sizes between different versions of 135coff; it is the duty of the coff version specific include file 136to override the definitions of various packing routines in 137@file{coffcode.h}. E.g., the size of line number entry in coff is 138sometimes 16 bits, and sometimes 32 bits. @code{#define}ing 139@code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the 140correct one. No doubt, some day someone will find a version of 141coff which has a varying field size not catered to at the 142moment. To port BFD, that person will have to add more @code{#defines}. 143Three of the bit twiddling routines are exported to 144@code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in} 145and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol 146table on its own, but uses BFD to fix things up. More of the 147bit twiddlers are exported for @code{gas}; 148@code{coff_swap_aux_out}, @code{coff_swap_sym_out}, 149@code{coff_swap_lineno_out}, @code{coff_swap_reloc_out}, 150@code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out}, 151@code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track 152of all the symbol table and reloc drudgery itself, thereby 153saving the internal BFD overhead, but uses BFD to swap things 154on the way out, making cross ports much safer. Doing so also 155allows BFD (and thus the linker) to use the same header files 156as @code{gas}, which makes one avenue to disaster disappear. 157 158@subsubsection Symbol reading 159The simple canonical form for symbols used by BFD is not rich 160enough to keep all the information available in a coff symbol 161table. The back end gets around this problem by keeping the original 162symbol table around, "behind the scenes". 163 164When a symbol table is requested (through a call to 165@code{bfd_canonicalize_symtab}), a request gets through to 166@code{coff_get_normalized_symtab}. This reads the symbol table from 167the coff file and swaps all the structures inside into the 168internal form. It also fixes up all the pointers in the table 169(represented in the file by offsets from the first symbol in 170the table) into physical pointers to elements in the new 171internal table. This involves some work since the meanings of 172fields change depending upon context: a field that is a 173pointer to another structure in the symbol table at one moment 174may be the size in bytes of a structure at the next. Another 175pass is made over the table. All symbols which mark file names 176(@code{C_FILE} symbols) are modified so that the internal 177string points to the value in the auxent (the real filename) 178rather than the normal text associated with the symbol 179(@code{".file"}). 180 181At this time the symbol names are moved around. Coff stores 182all symbols less than nine characters long physically 183within the symbol table; longer strings are kept at the end of 184the file in the string table. This pass moves all strings 185into memory and replaces them with pointers to the strings. 186 187The symbol table is massaged once again, this time to create 188the canonical table used by the BFD application. Each symbol 189is inspected in turn, and a decision made (using the 190@code{sclass} field) about the various flags to set in the 191@code{asymbol}. @xref{Symbols}. The generated canonical table 192shares strings with the hidden internal symbol table. 193 194Any linenumbers are read from the coff file too, and attached 195to the symbols which own the functions the linenumbers belong to. 196 197@subsubsection Symbol writing 198Writing a symbol to a coff file which didn't come from a coff 199file will lose any debugging information. The @code{asymbol} 200structure remembers the BFD from which the symbol was taken, and on 201output the back end makes sure that the same destination target as 202source target is present. 203 204When the symbols have come from a coff file then all the 205debugging information is preserved. 206 207Symbol tables are provided for writing to the back end in a 208vector of pointers to pointers. This allows applications like 209the linker to accumulate and output large symbol tables 210without having to do too much byte copying. 211 212This function runs through the provided symbol table and 213patches each symbol marked as a file place holder 214(@code{C_FILE}) to point to the next file place holder in the 215list. It also marks each @code{offset} field in the list with 216the offset from the first symbol of the current symbol. 217 218Another function of this procedure is to turn the canonical 219value form of BFD into the form used by coff. Internally, BFD 220expects symbol values to be offsets from a section base; so a 221symbol physically at 0x120, but in a section starting at 2220x100, would have the value 0x20. Coff expects symbols to 223contain their final value, so symbols have their values 224changed at this point to reflect their sum with their owning 225section. This transformation uses the 226@code{output_section} field of the @code{asymbol}'s 227@code{asection} @xref{Sections}. 228 229@itemize @bullet 230 231@item 232@code{coff_mangle_symbols} 233@end itemize 234This routine runs though the provided symbol table and uses 235the offsets generated by the previous pass and the pointers 236generated when the symbol table was read in to create the 237structured hierarchy required by coff. It changes each pointer 238to a symbol into the index into the symbol table of the asymbol. 239 240@itemize @bullet 241 242@item 243@code{coff_write_symbols} 244@end itemize 245This routine runs through the symbol table and patches up the 246symbols from their internal form into the coff way, calls the 247bit twiddlers, and writes out the table to the file. 248 249@findex coff_symbol_type 250@subsubsection @code{coff_symbol_type} 251@strong{Description}@* 252The hidden information for an @code{asymbol} is described in a 253@code{combined_entry_type}: 254 255 256@example 257 258typedef struct coff_ptr_struct 259@{ 260 /* Remembers the offset from the first symbol in the file for 261 this symbol. Generated by coff_renumber_symbols. */ 262 unsigned int offset; 263 264 /* Should the value of this symbol be renumbered. Used for 265 XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. */ 266 unsigned int fix_value : 1; 267 268 /* Should the tag field of this symbol be renumbered. 269 Created by coff_pointerize_aux. */ 270 unsigned int fix_tag : 1; 271 272 /* Should the endidx field of this symbol be renumbered. 273 Created by coff_pointerize_aux. */ 274 unsigned int fix_end : 1; 275 276 /* Should the x_csect.x_scnlen field be renumbered. 277 Created by coff_pointerize_aux. */ 278 unsigned int fix_scnlen : 1; 279 280 /* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the 281 index into the line number entries. Set by coff_slurp_symbol_table. */ 282 unsigned int fix_line : 1; 283 284 /* The container for the symbol structure as read and translated 285 from the file. */ 286 union 287 @{ 288 union internal_auxent auxent; 289 struct internal_syment syment; 290 @} u; 291 292 /* Selector for the union above. */ 293 bool is_sym; 294 295 /* An extra pointer which can used by format based on COFF (like XCOFF) 296 to provide extra information to their backend. */ 297 void *extrap; 298@} combined_entry_type; 299 300 301/* Each canonical asymbol really looks like this: */ 302 303typedef struct coff_symbol_struct 304@{ 305 /* The actual symbol which the rest of BFD works with */ 306 asymbol symbol; 307 308 /* A pointer to the hidden information for this symbol */ 309 combined_entry_type *native; 310 311 /* A pointer to the linenumber information for this symbol */ 312 struct lineno_cache_entry *lineno; 313 314 /* Have the line numbers been relocated yet ? */ 315 bool done_lineno; 316@} coff_symbol_type; 317@end example 318@findex bfd_coff_backend_data 319@subsubsection @code{bfd_coff_backend_data} 320 321@example 322/* COFF symbol classifications. */ 323 324enum coff_symbol_classification 325@{ 326 /* Global symbol. */ 327 COFF_SYMBOL_GLOBAL, 328 /* Common symbol. */ 329 COFF_SYMBOL_COMMON, 330 /* Undefined symbol. */ 331 COFF_SYMBOL_UNDEFINED, 332 /* Local symbol. */ 333 COFF_SYMBOL_LOCAL, 334 /* PE section symbol. */ 335 COFF_SYMBOL_PE_SECTION 336@}; 337 338typedef asection * (*coff_gc_mark_hook_fn) 339 (asection *, struct bfd_link_info *, struct internal_reloc *, 340 struct coff_link_hash_entry *, struct internal_syment *); 341 342@end example 343Special entry points for gdb to swap in coff symbol table parts: 344@example 345typedef struct 346@{ 347 void (*_bfd_coff_swap_aux_in) 348 (bfd *, void *, int, int, int, int, void *); 349 350 void (*_bfd_coff_swap_sym_in) 351 (bfd *, void *, void *); 352 353 void (*_bfd_coff_swap_lineno_in) 354 (bfd *, void *, void *); 355 356 unsigned int (*_bfd_coff_swap_aux_out) 357 (bfd *, void *, int, int, int, int, void *); 358 359 unsigned int (*_bfd_coff_swap_sym_out) 360 (bfd *, void *, void *); 361 362 unsigned int (*_bfd_coff_swap_lineno_out) 363 (bfd *, void *, void *); 364 365 unsigned int (*_bfd_coff_swap_reloc_out) 366 (bfd *, void *, void *); 367 368 unsigned int (*_bfd_coff_swap_filehdr_out) 369 (bfd *, void *, void *); 370 371 unsigned int (*_bfd_coff_swap_aouthdr_out) 372 (bfd *, void *, void *); 373 374 unsigned int (*_bfd_coff_swap_scnhdr_out) 375 (bfd *, void *, void *); 376 377 unsigned int _bfd_filhsz; 378 unsigned int _bfd_aoutsz; 379 unsigned int _bfd_scnhsz; 380 unsigned int _bfd_symesz; 381 unsigned int _bfd_auxesz; 382 unsigned int _bfd_relsz; 383 unsigned int _bfd_linesz; 384 unsigned int _bfd_filnmlen; 385 bool _bfd_coff_long_filenames; 386 387 bool _bfd_coff_long_section_names; 388 bool (*_bfd_coff_set_long_section_names) 389 (bfd *, int); 390 391 unsigned int _bfd_coff_default_section_alignment_power; 392 bool _bfd_coff_force_symnames_in_strings; 393 unsigned int _bfd_coff_debug_string_prefix_length; 394 unsigned int _bfd_coff_max_nscns; 395 396 void (*_bfd_coff_swap_filehdr_in) 397 (bfd *, void *, void *); 398 399 void (*_bfd_coff_swap_aouthdr_in) 400 (bfd *, void *, void *); 401 402 void (*_bfd_coff_swap_scnhdr_in) 403 (bfd *, void *, void *); 404 405 void (*_bfd_coff_swap_reloc_in) 406 (bfd *abfd, void *, void *); 407 408 bool (*_bfd_coff_bad_format_hook) 409 (bfd *, void *); 410 411 bool (*_bfd_coff_set_arch_mach_hook) 412 (bfd *, void *); 413 414 void * (*_bfd_coff_mkobject_hook) 415 (bfd *, void *, void *); 416 417 bool (*_bfd_styp_to_sec_flags_hook) 418 (bfd *, void *, const char *, asection *, flagword *); 419 420 void (*_bfd_set_alignment_hook) 421 (bfd *, asection *, void *); 422 423 bool (*_bfd_coff_slurp_symbol_table) 424 (bfd *); 425 426 bool (*_bfd_coff_symname_in_debug) 427 (bfd *, struct internal_syment *); 428 429 bool (*_bfd_coff_pointerize_aux_hook) 430 (bfd *, combined_entry_type *, combined_entry_type *, 431 unsigned int, combined_entry_type *); 432 433 bool (*_bfd_coff_print_aux) 434 (bfd *, FILE *, combined_entry_type *, combined_entry_type *, 435 combined_entry_type *, unsigned int); 436 437 void (*_bfd_coff_reloc16_extra_cases) 438 (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *, 439 bfd_byte *, unsigned int *, unsigned int *); 440 441 int (*_bfd_coff_reloc16_estimate) 442 (bfd *, asection *, arelent *, unsigned int, 443 struct bfd_link_info *); 444 445 enum coff_symbol_classification (*_bfd_coff_classify_symbol) 446 (bfd *, struct internal_syment *); 447 448 bool (*_bfd_coff_compute_section_file_positions) 449 (bfd *); 450 451 bool (*_bfd_coff_start_final_link) 452 (bfd *, struct bfd_link_info *); 453 454 bool (*_bfd_coff_relocate_section) 455 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 456 struct internal_reloc *, struct internal_syment *, asection **); 457 458 reloc_howto_type *(*_bfd_coff_rtype_to_howto) 459 (bfd *, asection *, struct internal_reloc *, 460 struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *); 461 462 bool (*_bfd_coff_adjust_symndx) 463 (bfd *, struct bfd_link_info *, bfd *, asection *, 464 struct internal_reloc *, bool *); 465 466 bool (*_bfd_coff_link_add_one_symbol) 467 (struct bfd_link_info *, bfd *, const char *, flagword, 468 asection *, bfd_vma, const char *, bool, bool, 469 struct bfd_link_hash_entry **); 470 471 bool (*_bfd_coff_link_output_has_begun) 472 (bfd *, struct coff_final_link_info *); 473 474 bool (*_bfd_coff_final_link_postscript) 475 (bfd *, struct coff_final_link_info *); 476 477 bool (*_bfd_coff_print_pdata) 478 (bfd *, void *); 479 480@} bfd_coff_backend_data; 481 482#define coff_backend_info(abfd) \ 483 ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) 484 485#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ 486 ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) 487 488#define bfd_coff_swap_sym_in(a,e,i) \ 489 ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) 490 491#define bfd_coff_swap_lineno_in(a,e,i) \ 492 ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) 493 494#define bfd_coff_swap_reloc_out(abfd, i, o) \ 495 ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) 496 497#define bfd_coff_swap_lineno_out(abfd, i, o) \ 498 ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) 499 500#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ 501 ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) 502 503#define bfd_coff_swap_sym_out(abfd, i,o) \ 504 ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) 505 506#define bfd_coff_swap_scnhdr_out(abfd, i,o) \ 507 ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) 508 509#define bfd_coff_swap_filehdr_out(abfd, i,o) \ 510 ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) 511 512#define bfd_coff_swap_aouthdr_out(abfd, i,o) \ 513 ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) 514 515#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) 516#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) 517#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) 518#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) 519#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) 520#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) 521#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) 522#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) 523#define bfd_coff_long_filenames(abfd) \ 524 (coff_backend_info (abfd)->_bfd_coff_long_filenames) 525#define bfd_coff_long_section_names(abfd) \ 526 (coff_backend_info (abfd)->_bfd_coff_long_section_names) 527#define bfd_coff_set_long_section_names(abfd, enable) \ 528 ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable)) 529#define bfd_coff_default_section_alignment_power(abfd) \ 530 (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) 531#define bfd_coff_max_nscns(abfd) \ 532 (coff_backend_info (abfd)->_bfd_coff_max_nscns) 533 534#define bfd_coff_swap_filehdr_in(abfd, i,o) \ 535 ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) 536 537#define bfd_coff_swap_aouthdr_in(abfd, i,o) \ 538 ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) 539 540#define bfd_coff_swap_scnhdr_in(abfd, i,o) \ 541 ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) 542 543#define bfd_coff_swap_reloc_in(abfd, i, o) \ 544 ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) 545 546#define bfd_coff_bad_format_hook(abfd, filehdr) \ 547 ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) 548 549#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ 550 ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) 551#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ 552 ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\ 553 (abfd, filehdr, aouthdr)) 554 555#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\ 556 ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ 557 (abfd, scnhdr, name, section, flags_ptr)) 558 559#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ 560 ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) 561 562#define bfd_coff_slurp_symbol_table(abfd)\ 563 ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) 564 565#define bfd_coff_symname_in_debug(abfd, sym)\ 566 ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) 567 568#define bfd_coff_force_symnames_in_strings(abfd)\ 569 (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings) 570 571#define bfd_coff_debug_string_prefix_length(abfd)\ 572 (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length) 573 574#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ 575 ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ 576 (abfd, file, base, symbol, aux, indaux)) 577 578#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\ 579 reloc, data, src_ptr, dst_ptr)\ 580 ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ 581 (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) 582 583#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ 584 ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ 585 (abfd, section, reloc, shrink, link_info)) 586 587#define bfd_coff_classify_symbol(abfd, sym)\ 588 ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ 589 (abfd, sym)) 590 591#define bfd_coff_compute_section_file_positions(abfd)\ 592 ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ 593 (abfd)) 594 595#define bfd_coff_start_final_link(obfd, info)\ 596 ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ 597 (obfd, info)) 598#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ 599 ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ 600 (obfd, info, ibfd, o, con, rel, isyms, secs)) 601#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ 602 ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ 603 (abfd, sec, rel, h, sym, addendp)) 604#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ 605 ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ 606 (obfd, info, ibfd, sec, rel, adjustedp)) 607#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\ 608 value, string, cp, coll, hashp)\ 609 ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ 610 (info, abfd, name, flags, section, value, string, cp, coll, hashp)) 611 612#define bfd_coff_link_output_has_begun(a,p) \ 613 ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p)) 614#define bfd_coff_final_link_postscript(a,p) \ 615 ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p)) 616 617#define bfd_coff_have_print_pdata(a) \ 618 (coff_backend_info (a)->_bfd_coff_print_pdata) 619#define bfd_coff_print_pdata(a,p) \ 620 ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p)) 621 622/* Macro: Returns true if the bfd is a PE executable as opposed to a 623 PE object file. */ 624#define bfd_pei_p(abfd) \ 625 (startswith ((abfd)->xvec->name, "pei-")) 626@end example 627@subsubsection Writing relocations 628To write relocations, the back end steps though the 629canonical relocation table and create an 630@code{internal_reloc}. The symbol index to use is removed from 631the @code{offset} field in the symbol table supplied. The 632address comes directly from the sum of the section base 633address and the relocation offset; the type is dug directly 634from the howto field. Then the @code{internal_reloc} is 635swapped into the shape of an @code{external_reloc} and written 636out to disk. 637 638@subsubsection Reading linenumbers 639Creating the linenumber table is done by reading in the entire 640coff linenumber table, and creating another table for internal use. 641 642A coff linenumber table is structured so that each function 643is marked as having a line number of 0. Each line within the 644function is an offset from the first line in the function. The 645base of the line number information for the table is stored in 646the symbol associated with the function. 647 648Note: The PE format uses line number 0 for a flag indicating a 649new source file. 650 651The information is copied from the external to the internal 652table, and each symbol which marks a function is marked by 653pointing its... 654 655How does this work ? 656 657@subsubsection Reading relocations 658Coff relocations are easily transformed into the internal BFD form 659(@code{arelent}). 660 661Reading a coff relocation table is done in the following stages: 662 663@itemize @bullet 664 665@item 666Read the entire coff relocation table into memory. 667 668@item 669Process each relocation in turn; first swap it from the 670external to the internal form. 671 672@item 673Turn the symbol referenced in the relocation's symbol index 674into a pointer into the canonical symbol table. 675This table is the same as the one returned by a call to 676@code{bfd_canonicalize_symtab}. The back end will call that 677routine and save the result if a canonicalization hasn't been done. 678 679@item 680The reloc index is turned into a pointer to a howto 681structure, in a back end specific way. For instance, the 386 682uses the @code{r_type} to directly produce an index 683into a howto table vector. 684@end itemize 685 686