链接器与加载器：深入理解计算机系统构建

需积分: 4 121 浏览量更新于2024-07-30 收藏 3.4MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源推荐

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

wanghaitrue

粉丝: 0
资源: 2

链接器与加载器：深入理解计算机系统构建

Linkers and Loaders.pdf

linkers and loaders-中文版.pdf_loader_linker_

Linkers and Loaders

Linkers & Loaders: Understanding the Process

链接与加载：深入理解Linkers和Loaders

linkers and loaders中文

ldd链接脚本学习资料

arm-arago-linux-gnueabi

codeblocks安装MPI环境

餐厅点餐系统springboot.zip

MATLAB_SIMULINK中的病毒传播模拟器.rar

Sigrity-Sigrity MCP Specification.rar

智能优化算法-樽海鞘优化算法（SSA）

CNG油改气 150+155+2.0+调试软件

为什么消费者喜欢生成式人工智能（英）(1).pdf

小红书教育行业月报（2023年7月）.pdf

海洋捕食者优化算法MPA-TCN-LSTM-Multihead-Attention多变量时间序列预测Matlab实现.rar

小红书3月大健康行业月报.pdf

016.jpg

最新资源