链接器与加载器：理解地址绑定与二进制接口

需积分: 17 189 浏览量更新于2024-07-16 收藏 3.55MB PDF 举报

"《Linkers & Loaders》是由John R. Levine编写的关于链接器和加载器技术的专业书籍。本书深入探讨了链接器和加载器在软件开发中的核心功能，以及它们如何处理程序的地址绑定、库管理、重定位等关键任务。书中还涉及了不同计算机架构下的二进制接口、内存管理、指令格式、过程调用等多个方面的内容。" 在软件开发中，链接器和加载器是至关重要的工具。它们的主要任务是将程序员使用的高级名字（如getline）与机器语言中的实际地址关联起来。这一过程称为地址绑定，使得抽象的编程概念能够与硬件层面的地址对应。链接器和加载器的工作通常分为两个阶段：链接和加载。链接阶段主要关注于合并编译后的对象文件，并解决符号引用。历史上，链接器的工作有时会分为两步，首次链接处理静态库，第二次链接处理动态库，以优化代码大小和性能。对象代码库允许链接器在需要时只包含必要的代码段。此外，链接器还需处理重定位，即修改代码以适应不同的内存地址，这涉及到对代码和数据的修改。加载阶段则是在程序运行时，将已链接的可执行文件加载到内存中，并进行必要的地址转换。书中提到了两种链接方式：静态链接和动态链接。静态链接在程序执行前完成所有链接，而动态链接则在运行时才进行，这使得共享库的使用成为可能，提高了内存效率。书中详细讨论了不同架构下的地址问题，如应用二进制接口（ABI）、内存地址表示、字节顺序和对齐要求。例如，IBM 370、SPARC、SPARCV8、SPARCV9、Intel x86架构都有各自独特的指令格式和过程调用机制。在x86架构中，还有分段机制来处理地址。此外，虚拟内存和页映射技术被引入来管理程序的地址空间，允许程序在不连续的物理内存中运行。对于嵌入式系统，由于其特殊的硬件限制，地址空间可能会有特殊的特性，比如非均匀内存访问（NUMA）结构。《Linkers & Loaders》这本书全面覆盖了链接器和加载器的原理和技术，不仅适用于操作系统开发者和低级程序员，也对理解软件运行机制的任何开发者都具有很高的参考价值。通过阅读此书，读者可以深入理解程序从源代码到可执行文件再到运行时内存映射的整个过程。

Linking and Loading 1-7

Chapter 1

Linking and Loading

$Revision: 2.3 $

$Date: 1999/06/30 01:02:35 $

What do linkers and loaders do?

The basic job of anylinker or loader is simple: it binds more abstract *

names to more concrete names, which permits programmers to write code *

using the more abstract names. That is, it takes a name written by a pro- *

grammer such as getline and binds it to ‘‘the location 612 bytes from *

the beginning of the executable code in module iosys.’’Oritmay takea *

more abstract numeric address such as ‘‘the location 450 bytes beyond the *

beginning of the static data for this module’’and bind it to a numeric ad- *

dress. *

Address binding: a historical perspective

Auseful way to get some insight into what linkers and loaders do is to

look at their part in the development of computer programming systems.

The earliest computers were programmed entirely in machine language.

Programmers would write out the symbolic programs on sheets of paper,

hand assemble them into machine code and then toggle the machine code

into the computer,orperhaps punch it on paper tape or cards. (Real hot-

shots could compose code directly at the switches.) If the programmer

used symbolic addresses at all, the symbols were bound to addresses as the

programmer did his or her hand translation. If it turned out that an instruc-

tion had to be added or deleted, the entire program had to be hand-inspect-

ed and anyaddresses affected by the added or deleted instruction adjusted.

The problem was that the names were bound to addresses too early.As-

semblers solved that problem by letting programmers write programs in

terms of symbolic names, with the assembler binding the names to ma-

chine addresses. If the program changed, the programmer had to reassem-

ble it, but the work of assigning the addresses is pushed offfrom the pro-

grammer to the computer.

1-8 Linking and Loading

Libraries of code compound the address assignment problem. Since the

basic operations that computers can perform are so simple, useful pro-

grams are composed of subprograms that perform higher leveland more

complexoperations. computer installations keep a library of pre-written

and debugged subprograms that programmers can drawupon to use in new

programs theywrite, rather than requiring programmers to write all their

ownsubprograms. The programmer then loads the subprograms in with

the main program to form a complete working program.

Programmers were using libraries of subprograms evenbefore theyused

assemblers. By 1947, John Mauchly,who led the ENIACproject, wrote

about loading programs along with subprograms selected from a catalog of

programs stored on tapes, and of the need to relocate the subprograms’

code to reﬂect the addresses at which theywere loaded. Perhaps surpris-

ingly,these twobasic linker functions, relocation and library search, ap-

pear to predate evenassemblers, as Mauchly expected both the program

and subprograms to be written in machine language. The relocating loader

allowed the authors and users of the subprograms to write each subpro-

gram as though it would start at location zero, and to defer the actual ad-

dress binding until the subprograms were linked with a particular main

program.

With the advent of operating systems, relocating loaders separate from

linkers and libraries became necessary.Before operating systems, each

program had the machine’sentire memory at its disposal, so the program

could be assembled and linked for ﬁxed memory addresses, knowing that

all addresses in the computer would be available. But with operating sys-

tems, the program had to share the computer’smemory with the operating

system and perhaps evenwith other programs, This means that the actual

addresses at which the program would be running weren’tknown until the

operating system loaded the program into memory,deferring ﬁnal address

binding past link time to load time. Linkers and loaders nowdivided up

the work, with linkers doing part of the address binding, assigning relative

addresses within each program, and the loader doing a ﬁnal relocation step

to assign actual addresses.

Linking and Loading 1-9

As systems became more complex, theycalled upon linkers to do more

and more complexname management and address binding. Fortran pro-

grams used multiple subprograms and common blocks, areas of data

shared by multiple subprograms, and it was up to the linker to lay out stor-

age and assign the addresses both for the subprograms and the common

blocks. Linkers increasingly had to deal with object code libraries. in-

cluding both application libraries written in Fortran and other languages,

and compiler support libraries called implcitly from compiled code to han-

dle I/O and other high-leveloperations.

Programs quickly became larger than available memory,solinkers provid-

ed overlays, a technique that let programmers arrange for different parts of

aprogram to share the same memory,with each overlay loaded on demand

when another part of the program called into it. Overlays were widely

used on mainframes from the advent of disks around 1960 until the spread

of virtual memory in the mid-1970s, then reappeared on microcomputers

in the early 1980s in exactly the same form, and faded as virtual memory

appeared on PCs in the 1990s. They’re still used in memory limited em-

bedded environments, and may yet reappear in other places where precise

programmer or compiler control of memory usage improvesperformance.

With the advent of hardware relocation and virtual memory,linkers and

loaders actually got less complex, since each program could again have an

entire address space. Programs could be linked to be loaded at ﬁxed ad-

dresses, with hardware rather than software relocation taking care of any

load-time relocation. But computers with hardware relocation invariably

run more than one program, frequently multiple copies of the same pro-

gram. When acomputer runs multiple instances of one program, some

parts of the program are the same among all running instance (the ex-

ecutable code, in particular), while other parts are unique to each instance.

If the parts that don’tchange can be separated out from the parts that do

change, the operating system can use a single copyofthe unchanging part,

saving considerable storage. Compilers and assemblers were modiﬁed to

create object code in multiple sections, with one section for read only code

and another section for writable data, the linker had to be able to combine

all of sections of each type so that the linked program would have all the

code in one place and all of the data in another.This didn’tdelay address

1-10 Linking and Loading

binding anymore than it already was, since addresses were still assigned

at link time, but more work was deferred to the linker to assign addresses

for all the sections.

Even when different programs are running on a computer,those different

programs usually turn out to share a lot of common code. Forexample,

nearly every program written in C uses routines such as fopen and

printf,database applications all use a large access library to connect to

the database, and programs running under a GUI such as X Window, MS

Windows, or the Macintosh all use pieces of the GUI library.Most sys-

tems nowprovide shared libraries for programs to use, so that all the pro-

grams that use a library can share a single copyofit. This both improves

runtime performance and savesalot of disk space; in small programs the

common library routines often takeupmore space than the program itself.

In the simpler static shared libraries, each library is bound to speciﬁc ad-

dresses at the time the library is built, and the linker binds program refer-

ences to library routines to those speciﬁc addresses at link time. Static li-

braries turn out to be inconveniently inﬂexible, since programs potentially

have toberelinked every time anypart of the library changes, and the de-

tails of creating static shared libraries turn out to be very tedious. Systems

added dynamically linked libraries in which library sections and symbols

aren’tbound to actual addresses until the program that uses the library

starts running. Sometimes the binding is delayed evenfarther than that;

with full-ﬂedged dynamic linking, the addresses of called procedures

aren’tbound until the ﬁrst call. Furthermore, programs can bind to li-

braries as the programs are running, loading libraries in the middle of pro-

gram execution. This provides a powerful and high-performance way to

extend the function of programs. Microsoft Windows in particular makes

extensive use of runtime loading of shared libraries (known as DLLs, Dy-

namically Linked Libraries) to construct and extend programs.

Linking vs. loading

Linkers and loaders perform several related but conceptually separate ac-

tions.

Linking and Loading 1-11

• Programloading: Copyaprogram from secondary storage (which

since about 1968 invariably means a disk) into main memory so

it’sready to run. In some cases loading just involves copying the

data from disk to memory,inothers it involves allocating storage,

setting protection bits, or arranging for virtual memory to map vir-

tual addresses to disk pages.

• Relocation: Compilers and assemblers generally create each ﬁle of

object code with the program addresses starting at zero, but few

computers let you load your program at location zero. If a pro-

gram is created from multiple subprograms, all the subprograms

have tobeloaded at non-overlapping addresses. Relocation is the

process of assigning load addresses to the various parts of the pro-

gram, adjusting the code and data in the program to reﬂect the as-

signed addresses. In manysystems, relocation happens more than

once. It’squite common for a linker to create a program from mul-

tiple subprograms, and create one linked output program that starts

at zero, with the various subprograms relocated to locations within

the big program. Then when the program is loaded, the system

picks the actual load address and the linked program is relocated as

awhole to the load address.

• Symbol resolution: When a program is built from multiple subpro-

grams, the references from one subprogram to another are made

using symbols; a main program might use a square root routine

called sqrt,and the math library deﬁnes sqrt.Alinker resolves

the symbol by noting the location assigned to sqrt in the library,

and patching the caller’sobject code to so the call instruction refers

to that location.

Although there’sconsiderable overlap between linking and loading, it’s

reasonable to deﬁne a program that does program loading as a loader,and

one that does symbol resolution as a linker.Either can do relocation, and

there have been all-in-one linking loaders that do all three functions.

The line between relocation and symbol resolution can be fuzzy.Since

linkers already can resolvereferences to symbols, one way to handle code

relocation is to assign a symbol to the base address of each part of the pro-

剩余298页未读，继续阅读

gnu1990

粉丝: 0
资源: 6

链接器与加载器：理解地址绑定与二进制接口

linkers and loaders-中文版.pdf_loader_linker_

Linkers & Loaders

Linkers & Loaders write by John R. Levine

Linkers and Loaders.pdf

linkers and loaders.pdf

Linkers & Loaders 英文版原著

linkers_and_loaders.pdf

Linkers & Loaders 翻译版：探索链接与加载的奥秘

Linker and Loaders.pdf

linkers and loaders-中文版.pdf

最新资源