Ãëàâíàÿ    Ex Libris    Êíèãè    Æóðíàëû    Ñòàòüè    Ñåðèè    Êàòàëîã    Wanted    Çàãðóçêà    ÕóäËèò    Ñïðàâêà    Ïîèñê ïî èíäåêñàì    Ïîèñê    Ôîðóì   
blank
Àâòîðèçàöèÿ

       
blank
Ïîèñê ïî óêàçàòåëÿì

blank
blank
blank
Êðàñîòà
blank
Levine J.R. — Linkers and Loaders [compilers, ELF]
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.


ßçûê: en

Ðóáðèêà: Computer science/

Ñòàòóñ ïðåäìåòíîãî óêàçàòåëÿ: Ãîòîâ óêàçàòåëü ñ íîìåðàìè ñòðàíèö

ed2k: ed2k stats

Ãîä èçäàíèÿ: 2000

Êîëè÷åñòâî ñòðàíèö: 266

Äîáàâëåíà â êàòàëîã: 17.10.2010

Îïåðàöèè: Ïîëîæèòü íà ïîëêó | Ñêîïèðîâàòü ññûëêó äëÿ ôîðóìà | Ñêîïèðîâàòü ID
blank
Ïðåäìåòíûé óêàçàòåëü
"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
1 2 3 4
blank
Ðåêëàìà
blank
blank
HR
@Mail.ru
       © Ýëåêòðîííàÿ áèáëèîòåêà ïîïå÷èòåëüñêîãî ñîâåòà ìåõìàòà ÌÃÓ, 2004-2024
Ýëåêòðîííàÿ áèáëèîòåêà ìåõìàòà ÌÃÓ | Valid HTML 4.01! | Valid CSS! Î ïðîåêòå