Àâòîðèçàöèÿ
Ïîèñê ïî óêàçàòåëÿì
Levine J.R. — Linkers and Loaders [compilers, ELF]
Îáñóäèòå êíèãó íà íàó÷íîì ôîðóìå
Íàøëè îïå÷àòêó? Âûäåëèòå åå ìûøêîé è íàæìèòå Ctrl+Enter
Íàçâàíèå: Linkers and Loaders [compilers, ELF]
Àâòîð: Levine J.R.
Àííîòàöèÿ: Written for any programmer who works with compiled code, Linkers and Loaders surveys today's hardware platforms with a tour of how code is linked and executed on IBM mainframes, Unix, and Windows. This handy title fills a valuable niche for anyone who wants to understand how programs are built and run on today's computing systems.
It's the cross-platform perspective that distinguishes this book. The author's wide-ranging perspective on IBM 370 mainframes, RISC platforms like the SUN SPARC and, of course, Microsoft Windows makes this book a commendable reference on the internals of linkers and program execution in each environment. There's also a digestible guide to the computer architecture (including registers, instruction formats, and memory addressing) for each platform. (Unix programmers will be pleased that the book has more information on non-Windows platforms than on Windows itself.) For C++ programmers, this text gives you a glimpse into the internals of such language features as macros, templates, and name mangling, and how linkers deal with them at build time.
The book closes with useful material on static libraries and dynamic linking, plus a short tour of Java and its class loader (which can resolve classes on the fly as they are downloaded over the Internet). Short exercises are provided for each chapter, making this a useful resource for both classroom and self-study on what is an often overlooked topic.
ßçûê:
Ðóáðèêà: Computer science /
Ñòàòóñ ïðåäìåòíîãî óêàçàòåëÿ: Ãîòîâ óêàçàòåëü ñ íîìåðàìè ñòðàíèö
ed2k: ed2k stats
Ãîä èçäàíèÿ: 2000
Êîëè÷åñòâî ñòðàíèö: 266
Äîáàâëåíà â êàòàëîã: 17.10.2010
Îïåðàöèè: Ïîëîæèòü íà ïîëêó |
Ñêîïèðîâàòü ññûëêó äëÿ ôîðóìà | Ñêîïèðîâàòü ID
Ïðåäìåòíûé óêàçàòåëü
"Big-endian" byte order schemes 21 139
"Bit creep" 150
"Blank" common 98
"Digital origami" 184
"Linkage editor" 234
"Little-endian" byte order schemes 21
"Universal intermediate languages" 240
.bss sections 61 66 96 192
.comment sections 66
.data sections 66
.debug sections 66
.dynstr sections 66
.dynsym sections 66
.edata sections 218—219
.fini sections 66 70 209 212—213
.got sections 66
.idata sections 218—222
.init sections 66 70 198 200 209 212—213
.interp sections 66 209
.plt sections 66
.rel.data sections 66
.rel.rodata sections 66
.rel.text sections 65
.rodata sections 66
.strtab sections 66
.symtab sections 66
.text sections 65 67
.tls sections 222
370 see "IBM 370"
386 see "Intel x86"
486 see "Intel x86"
64-bit architecture, extending archives to 140
a.out files 50—55 90 see
a.out files, archives in 138
a.out files, drawbacks 61—62
a.out files, headers for 51—52
a.out files, interactions with virtual memory 52—55
a.out files, linking in 110
a.out files, loading into a process 53
a.out files, QMAGIC 55
a.out files, simplified example 50
a.out files, storage allocation in 109—111
a.out files, ZMAGIC 54
ABIs see "Application binary interfaces (ABIs)"
ABS pseudo-sections 67
Abs symbols 61
Absolute address references, adjusting 151
Absolute address references, hacking 156
Address binding 40
Address binding, deferred 3—4
Address binding, historical perspective 1—4
Address conflicts 201
Address formation 22—23
Address Pool 10
Address space, managing 190—191
Address space, program 36—37
Address space, quirks of 43—44
Address space, segmented 29
addressability 24—27 30
Addresses see "Data addressing"
Addresses in storage allocation 93—94
Addresses, calculating 33
Addresses, memory 20—22
Addresses, patching to 14
Addresses, segmented 32
Addresses, symbolic 2
Addresses, synthesizing 32
Addresses, table of 20
Addressing, based 23
Addressing, direct 23 24
Addressing, indexed 23
Addressing, pseudo-direct 31
Addressing, relative 155
advanced techniques 229—245
AIX 169 171
Alignment, memory 44
Alignment, requirements for 22
Alpha, LITERAL for 162
Annotated C++ Reference Manual 127
Application binary interfaces(ABIs) 20 25
architectural issues 19—46
Architectural issues, address formation 22—23
Architectural issues, application binary interfaces (ABIs) 20
Architectural issues, data and instruction references 28—34
Architectural issues, embedded architectures 43—44
Architectural issues, instruction formats 23—24
Architectural issues, Intel 386 segmentation 41—43
Architectural issues, memory addresses 20—22
Architectural issues, paging and virtual memory 34—40
Architectural issues, procedure calls and addressability 24—27
Architectural issues, segmenting 49
Archive format 136—138 see
arguments, passing 25
AS/400, binary translation in 245
assemblers 2
Assemblers, generating object files 8
Assemblers, link-time 239—240
AT&T 62
Auxiliary vectors, passing 210
Base registers 26 28 41
Based addressing 23
BeOS 224
Binaries, slim 240
Binaries, verifying 242
Binary translation 245
Binding in symbol management 117—118
Binding time, in shared libraries 188—190
Binding, addresses 3—4 40
Binding, lazy 213
Binding, run-time 150
Bitmaps, and relocation 161
BLOCK DATA 99
Bootstrap loading 176—177 210
Bootstrap sequence, intercepting 177
Bootstrapping, defined 176
Bootstrapping, problems with 24 27
Branches see "Jump instructions"
bridges 169
BSD Unix 51 55 58
BSD/OS 190 197—198
buffers 8 44
Byte-addressable memory 20—22
bytes 20—21
C programming language 4 11
C programming language, executable code in 16
C programming language, indirect calls in 221
C programming language, name mangling in 125—126
C programming language, null pointers in 37
C programming language, object code for 14—15
C programming language, pointers in 170
C programming language, source files in 13
C++programming language 11 62 70 75
C++programming language, databases in 232—233
C++programming language, debugging in 131—132
C++programming language, duplicate code removal in 99—103 232
C++programming language, global initializers and destructors in 229
C++programming language, indirect calls in 221
C++programming language, name mangling in 126—128 229
C++programming language, techniques for 229—233
C++programming language, templates in 230
C++programming language, Visual 236
C0MDAT sections 232
Cache files see "Library cache files"
Calling sequence, idealized 27
Calls 27 32 see
Calls, exclusive 179
Calls, hardware 25
calls, indirect 221
Calls, marking 13 45
Chained references, in relocation 160—161
Checking code 184
Chip designs 21—22
Circular buffers 44
Class-at-a-time translation 244
Classes in Java 241
Classes, loading 242
ClassLoader 242
CM (common) type symbols 72
Code generation, link-time 238—240
Code generation, load-time 240—241
Code modification in relocation 8—10
Code modification, relocation and 8—10
Code sections, and UNIX a.out files 50—55
Code sets, initialization 10
Code, duplicate 99—103 183 232
Code, executable 4 16
Code, glue 7 181—182
Code, large model 42
Code, libraries of 2 26
Code, medium model 42
Code, position-independent 40
Code, small model 42
Code, startup 14
Code, unrelocated 39
Code, x86 8—10
CodeWarrior 236
COFF (Common Object File Format) files 62 see "XCOFF
COFF (Common Object File Format) files and Microsoft Portable Executable (PE) format 75 83
COFF (Common Object File Format) files, directory format 139
COFF (Common Object File Format) files, example 77
COFF (Common Object File Format) files, headers for 78—80
COFF (Common Object File Format) files, stub libraries in 195
COM files see "DOS COM files"
COMDAT flag 101
COMDEF records 87
COMENT records 86—88
Command languages, embedded in object files 12
Command languages, intermixed with object files 12
Command languages, linker 11—12
Command languages, separate configuration language 12
command line 12
Command line switches 108 211
Common blocks 98
Common blocks in UNIX 100
Common blocks, declaring 99 114
COMMON pseudo-sections 67
Common storage 98—99
Compatibility problems with binary programs 241
Compatibility problems with jump tables 201—202
compilation process 10—11
Compiler drivers 10—12 230
Compilers, generating object files 8
Compilers, history of 187
Conditional jump instructions 31 34
Configuration language 12
Constant pools 243
Control scripts, in storage allocation 107—109
Copy-on-write (COW) files 38—39 168
Csects 71—72 75
Cumulative external dummy (CXD) relocation type 104
DATA see "Static data"
Data addressing 25
Data addressing, adjusting 151
Data addressing, allocating local variables 25
Data addressing, passing arguments 25
Data addressing, storing global static data 25
Data addressing, storing local static data 25
Data and instruction references 28—34
Data and instruction references, IBM 370 28—30
Data and instruction references, Intel x86 32—34
Data and instruction references, misaligned 22
Data and instruction references, SPARC 30—32
Data sets, partitioned 136
Data symbols 61
Data, pushing and popping 26 33
Databases, in C++ programming language 232—233
Debugging 7—8 15 48 62
Debugging, passing information through 131—132
Debugging, wrapping for 184
DEC OM optimizing linker 237
DEC TOPS-10 assembler 236
decompiling 237
Define Class 242
Delay-loaded imports 221
Destructors, global 229
Digital signal processors (DSPs) 43 161 177
Digital VAX VMS 75
Direct addressing 23 24 40
Disk space, cost of 190
Displacement 34
DLLs see "Dynamically linked libraries (DLLs)"
dlopen 216—217
DOS COM files 49 90
DOS EXE files 49 56—58 76
DOS EXE files, headers for 57
DOS EXE files, relocation in 56—58 168—169
Drivers, compiler 10—12
DSPs see "Digital signal processors"
Duplicated code, in overlays 183
DWARF 62
Dynamic loading, run time 216—217
DYNAMIC type sections 65 208
Dynamically linked libraries (DLLs) and thread local storage 222
Dynamically linked libraries (DLLs) in MS Windows 217—222
Dynamically linked shared libraries 4 75—76 205—227
Dynamically linked shared libraries, compared with static 224—225
Dynamically linked shared libraries, ELF 206—213
Dynamically linked shared libraries, finding libraries in 211—212
Dynamically linked shared libraries, initialization 212—213
Dynamically linked shared libraries, lazy procedure linkage 213—215
Dynamically linked shared libraries, peculiarities of 215—216
Dynamically linked shared libraries, starting 210—211
DYNSYM type sections 64 66
ECOFF files and relocation 157—158
ECOFF files, archives in 139—140 142
ECOFF files, lack of structure in 239
ELF (Executable and Linking Format) files 62—70 90 112
ELF (Executable and Linking Format) files and relocatable files 63—68 158—159
ELF (Executable and Linking Format) files, advantages 69
ELF (Executable and Linking Format) files, components defined 206—207
ELF (Executable and Linking Format) files, directory format 139
ELF (Executable and Linking Format) files, dynamically linked libraries (DLLs) in 206—209 224—225
ELF (Executable and Linking Format) files, example 68
ELF (Executable and Linking Format) files, executable 68—70
ELF (Executable and Linking Format) files, headers for 62 64
ELF (Executable and Linking Format) files, loadable segments for 69
ELF (Executable and Linking Format) files, position-independent code (PIC) in 172—175
ELF (Executable and Linking Format) files, program headers for 69
ELF (Executable and Linking Format) files, section headers for 65
ELF (Executable and Linking Format) files, static shared libraries in 175 226
ELF (Executable and Linking Format) files, storage allocation in 111—113
ELF (Executable and Linking Format) files, symbol table for 67 210—211
ELF (Executable and Linking Format) files, weak external symbols in 145
Embedded architectures 43—44
Embedded architectures, address space quirks in 43—44
Embedded architectures, memory alignment 44
Embedded architectures, non-uniform memory 44
END format 71 74 75
ER (external reference) type symbols 73
Error routines 15
ESD format 71 72
ESIDs see "External Symbol IDs (ESIDs)"
Etch 239
Exclusive calls 179
EXE files see "DOS EXE files"
Executable code 4 16
Executable files 48
Executable files in ELF 62 68—70
Executable files in shared libraries 192
Exports, in Microsoft Portable Executable (PE) format 81
Ðåêëàìà