<html lang="en">
<head>
<title>BFD - Untitled</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Untitled">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="prev" href="Machine-Dependent.html#Machine-Dependent" title="Machine Dependent">
<link rel="next" href="Reporting-Bugs.html#Reporting-Bugs" title="Reporting Bugs">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
This file documents the GNU linker LD
(Sourcery G++ Lite 2011.03-41)
version 2.20.51.

Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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 no Invariant Sections, with no Front-Cover Texts, and with no
Back-Cover Texts.  A copy of the license is included in the
section entitled ``GNU Free Documentation License''.-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
  pre.display { font-family:inherit }
  pre.format  { font-family:inherit }
  pre.smalldisplay { font-family:inherit; font-size:smaller }
  pre.smallformat  { font-family:inherit; font-size:smaller }
  pre.smallexample { font-size:smaller }
  pre.smalllisp    { font-size:smaller }
  span.sc    { font-variant:small-caps }
  span.roman { font-family:serif; font-weight:normal; } 
  span.sansserif { font-family:sans-serif; font-weight:normal; } 
--></style>
<link rel="stylesheet" type="text/css" href="../cs.css">
</head>
<body>
<div class="node">
<a name="BFD"></a>
<p>
Next:&nbsp;<a rel="next" accesskey="n" href="Reporting-Bugs.html#Reporting-Bugs">Reporting Bugs</a>,
Previous:&nbsp;<a rel="previous" accesskey="p" href="Machine-Dependent.html#Machine-Dependent">Machine Dependent</a>,
Up:&nbsp;<a rel="up" accesskey="u" href="index.html#Top">Top</a>
<hr>
</div>

<h2 class="chapter">5 BFD</h2>

<p><a name="index-back-end-676"></a><a name="index-object-file-management-677"></a><a name="index-object-formats-available-678"></a><a name="index-objdump-_002di-679"></a>The linker accesses object and archive files using the BFD libraries. 
These libraries allow the linker to use the same routines to operate on
object files whatever the object file format.  A different object file
format can be supported simply by creating a new BFD back end and adding
it to the library.  To conserve runtime memory, however, the linker and
associated tools are usually configured to support only a subset of the
object file formats available.  You can use <code>objdump -i</code>
(see <a href="../binutils/objdump.html#objdump">objdump</a>) to
list all the formats available for your configuration.

   <p><a name="index-BFD-requirements-680"></a><a name="index-requirements-for-BFD-681"></a>As with most implementations, BFD is a compromise between
several conflicting requirements. The major factor influencing
BFD design was efficiency: any time used converting between
formats is time which would not have been spent had BFD not
been involved. This is partly offset by abstraction payback; since
BFD simplifies applications and back ends, more time and care
may be spent optimizing algorithms for a greater speed.

   <p>One minor artifact of the BFD solution which you should bear in
mind is the potential for information loss.  There are two places where
useful information can be lost using the BFD mechanism: during
conversion and during output. See <a href="BFD-information-loss.html#BFD-information-loss">BFD information loss</a>.

<ul class="menu">
<li><a accesskey="1" href="BFD-outline.html#BFD-outline">BFD outline</a>:                  How it works: an outline of BFD
</ul>

   </body></html>

