深入理解链接器与加载器：程序运行基石

需积分: 3 4 浏览量更新于2024-08-01 收藏 3.42MB PDF 举报

《链接器与装载器》是一本由John R. Levine撰写的经典著作，专为那些希望深入理解程序底层运行机制的程序员设计。本书详细探讨了链接器和装载器在软件开发中的核心作用，将理论知识与实践案例相结合，使读者能够清晰地把握这两个关键组件的工作原理。首先，章节一"链接和加载"（Chapter 1）解释了链接器和装载器的基本功能。链接器负责将编译后的目标代码（object code）与所需的库函数、数据和资源进行整合，形成可执行文件，确保地址绑定和代码修改的正确性。它区分了链接（Linking）的两个阶段：一阶段是符号解析，二阶段是实际代码合并。此外，对象代码库、重定位和代码修改技术也是此章的重点，通过实例来演示链接器如何处理不同的指令集架构（如IBM 370、SPARC和Intel x86）。接下来，第二章"架构问题"（Chapter 2）探讨了架构相关的挑战。这部分涉及应用二进制接口（ABI），即不同处理器之间的标准接口，保证不同平台上的兼容性。内存地址管理、字节序和对齐、地址形成机制以及各种处理器的特定指令格式和内存访问模型（如SPARC V8、V9和Intel x86的段寄存器机制）都在这里进行了详尽的阐述。此外，虚拟内存、程序地址空间、映射文件、共享库与程序的链接方式，以及针对嵌入式系统和非均匀内存的特殊考虑也被纳入讨论。对于程序员来说，理解链接器和装载器的工作原理至关重要，因为这关系到代码的移植性和效率。通过阅读这本书，读者不仅能掌握基本概念，还能学会如何编写和优化链接器命令语言，以及如何处理各种架构下程序的编译链接过程。书中提供的大量练习题有助于巩固所学知识，并将其应用于实际项目中。《链接器与装载器》不仅是一本理论教材，还是一本实践指导，对于软件工程师提升底层技术素养具有极大的价值。无论你是刚入门的开发者，还是经验丰富的技术专家，都能从中收获丰富的见解和技能提升。

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页未读，继续阅读

luomoweilan

粉丝: 128
资源: 12

深入理解链接器与加载器：程序运行基石

linker and loader 中文版

linker and loader 中英文.zip

linker and loader introuction

linker and loader.rar

linker and loader 下载

链接器与加载器 linker and loader

中国新能源汽车&充电桩（2018-2022）数据-最新出炉.zip

JDK17 win64位版本下载

【SCI一区】Matlab实现哈里斯鹰优化算法HHO-CNN-LSTM-Attention的风电功率预测算法研究.rar

Python 实现PSO-RBF和RBF粒子群优化算法优化径向基函数神经网络多输入单输出回归预测（含完整的程序和代码详解）

最新资源