<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This file documents the BFD library.

Copyright (C) 1991 - 2013 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "Funding
Free Software", the Front-Cover texts being (a) (see below), and with
the Back-Cover Texts being (b) (see below).  A copy of the license is
included in the section entitled "GNU Free Documentation License".

(a) The FSF's Front-Cover Text is:

A GNU Manual

(b) The FSF's Back-Cover Text is:

You have freedom to copy and modify this GNU Manual, like GNU
     software.  Copies published by the Free Software Foundation raise
     funds for GNU development. -->
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>Untitled Document: Differing file formats</title>

<meta name="description" content="Untitled Document: Differing file formats">
<meta name="keywords" content="Untitled Document: Differing file formats">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="BFD-Index.html#BFD-Index" rel="index" title="BFD Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Adding-Symbols-to-the-Hash-Table.html#Adding-Symbols-to-the-Hash-Table" rel="up" title="Adding Symbols to the Hash Table">
<link href="Adding-symbols-from-an-object-file.html#Adding-symbols-from-an-object-file" rel="next" title="Adding symbols from an object file">
<link href="Adding-Symbols-to-the-Hash-Table.html#Adding-Symbols-to-the-Hash-Table" rel="prev" title="Adding Symbols to the Hash Table">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>


</head>

<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Differing-file-formats"></a>
<div class="header">
<p>
Next: <a href="Adding-symbols-from-an-object-file.html#Adding-symbols-from-an-object-file" accesskey="n" rel="next">Adding symbols from an object file</a>, Previous: <a href="Adding-Symbols-to-the-Hash-Table.html#Adding-Symbols-to-the-Hash-Table" accesskey="p" rel="prev">Adding Symbols to the Hash Table</a>, Up: <a href="Adding-Symbols-to-the-Hash-Table.html#Adding-Symbols-to-the-Hash-Table" accesskey="u" rel="up">Adding Symbols to the Hash Table</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="BFD-Index.html#BFD-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Differing-file-formats-1"></a>
<h4 class="subsubsection">2.17.2.1 Differing file formats</h4>
<p>Normally all the files involved in a link will be of the same
format, but it is also possible to link together different
format object files, and the back end must support that.  The
<code>_bfd_link_add_symbols</code> entry point is called via the target
vector of the file to be added.  This has an important
consequence: the function may not assume that the hash table
is the type created by the corresponding
<code>_bfd_link_hash_table_create</code> vector.  All the
<code>_bfd_link_add_symbols</code> function can assume about the hash
table is that it is derived from <code>struct
bfd_link_hash_table</code>.
</p>
<p>Sometimes the <code>_bfd_link_add_symbols</code> function must store
some information in the hash table entry to be used by the
<code>_bfd_final_link</code> function.  In such a case the output bfd
xvec must be checked to make sure that the hash table was
created by an object file of the same format.
</p>
<p>The <code>_bfd_final_link</code> routine must be prepared to handle a
hash entry without any extra information added by the
<code>_bfd_link_add_symbols</code> function.  A hash entry without
extra information will also occur when the linker script
directs the linker to create a symbol.  Note that, regardless
of how a hash table entry is added, all the fields will be
initialized to some sort of null value by the hash table entry
initialization function.
</p>
<p>See <code>ecoff_link_add_externals</code> for an example of how to
check the output bfd before saving information (in this
case, the ECOFF external symbol debugging information) in a
hash table entry.
</p>



</body>
</html>
