Ãëàâíàÿ    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
Ïðåäìåòíûé óêàçàòåëü
Null pointers, problems with      37
Null sections      63
Oberon      240
Object code      48
Object code for C programming language      14—15
Object code libraries      8—9
Object code, patching      6
object files      47—92
Object files and code sections      50—55
Object files, and relocation      56—58 153
Object files, and the null object format      49
Object files, commands embedded in      12
Object files, commands intermixed with      12
Object files, contents of      47—49
Object files, DOS COM files      49
Object files, DOS EXE files      56—58
Object files, format comparison      90
Object files, generating      8 11
Object files, IBM 360 object format      71—75
Object files, Intel/Microsoft OMF files      84—89
Object files, Microsoft Portable Executable (PE) format      75—84
Object files, relocatable a.out files      58—62
Object files, symbols      58
Object files, two-section      50
Object files, UNIX a.out files      50—55
Object files, UNIX ELF      62—70
Object formats, designing      48—49
Object formats, relinkable      7
OMF (Object Module Format) files      84—89 90 106
OMF (Object Module Format) files, and relocation      159
OMF (Object Module Format) files, details of      86—89
OMF (Object Module Format) files, drawbacks      89
OMF (Object Module Format) files, libraries in      140—141 142
OMF (Object Module Format) files, record types in      85—86
OMF (Object Module Format) files, typical record sequence      87
One-pass linking      8
Open Software Foundation      222
Operating systems      see "Individual operating systems"
Operating systems, advent of      2—3
Operating systems, loading      176—177
Operating systems, setting stack pointer register      25—26
Optimization of calling sequence      27
Optimization, link-time      237—238 244
OS/360      29
OS/390      75
OSF/1, pseudo-static shared libraries in      222—223
Output formats, and relocation      159—160
OVERLAY commands      179
Overlay segment table      184
Overlays      177—186
Overlays, data in      182—183
Overlays, defined      179—181
Overlays, duplicated code in      183
Overlays, implementing      181—182
Overlays, multiple regions in      183
Overlays, tree structured      177—184
Overrides, segment      41
p-code      17
Page alignment, in storage allocation      96—98
page faults      34—35
Page frames      34
Page tables      34 36 39
Page tables, lower-level      36
Page tables, upper-level      36
pages, defined      34
Pages, mapping      35
Paging systems and mapped files      37—39
Paging systems and position-independent code      39—40
Paging systems and shared libraries and programs      39
Paging systems and virtual memory      34—40
Paging systems for reading and writing      38
Paging systems, program address space in      36—37
Paragraphs      41
Partitioned data sets (PDSs)      136
passing arguments      25
Patching      14
Paths      178
PC (private code) type symbols      71—72
PDP-10      46
PDP-11      36 144 161
PDP-6      46
PDSS      see "Partitioned data sets (PDSs)"
PE format      see "Microsoft Portable Executable (PE) format"
Pentium      see "Intel x86"
Per-routine pointer tables, and position-independent code (PIC)      171
Per-thread storage      105
Perl programming language      92
Phar Lap      84
PIC      see "Position-independent code (PIC)"
PLTGOT pointers      208
PLTREL pointers      208
PLTRELSZ pointers      208
PLTs      see "Procedure linking tables (PLTs)"
Pointer tables, generating      26
Pointer tables, per-routine      171
Pointers in C      170
Pointers, accessing code with      171
Pointers, null      37
Pointers, stack      25
Pop instructions      26 33
Portable Executable (PE) format      see "Microsoft Portable Executable (PE) format"
Position-independent code (PIC)      40
Position-independent code (PIC) in loading      169—176 207
Position-independent code (PIC), costs and benefits      175—176
Position-independent code (PIC), ELF      172—175
Position-independent code (PIC), per-routine pointer tables      171
Position-independent code (PIC), tables of contents (TOC)      171—172
Position-independent code (PIC), TSS/360      170
PowerPC CPU      241
PR (pseudo-register) type symbols      73
Preparation, of binary code      242
Procedure calls      20 25—27 170
Procedure linking tables (PLTs)      206—208 213—215
PROGBITS type sections      64—66
Program address space      36—37
Program addressing      19
Program files, relocation information in      37
Program headers, for ELF files      69
Program loading      5 210—213
Program Segment Prefix (PSP)      48 57
Programming languages      see "Command languages" "Individual
Programming, early      1—2
Programming, using libraries      2
Programs, executable      14
Programs, shared      39
Project, adding garbage collection to      245
Project, adding library searching to      146—148
Project, adding wrapping      185
Project, extending to shared libraries      227
Project, format for object files      91—93
Project, handling relocation in      164—165
Project, implementing storage allocation      115
Project, producing static shared libraries      203—204
Project, symbol management for      133
Protected mode      33
Pseudo-registers      103—105 163
Pseudo-sections      67
Pseudo-static shared libraries, in OSF/1      222—223
PSP      see "Program Segment Prefix (PSP)"
PUBDEF records      87
Push instructions      26 33
Pushl instruction, marking      13
QMAGIC a.out files      53—55 69 110—112
QuickStart      224
R-con address      170
Read-only (RO) files      38 39 168
Read/write (RW) files      38
Real mode      41
Rebasing      218
Record types, in OMF files      85—86
Register indirect      23
Register windows      31
Registers      22
Registers, base      26 28 41
Registers, scratch      27
Registers, table pointer      26
Registers, updating      26
REL pointers      208
REL type sections      65 66
RELA pointers      208
RELA type sections      65 66
RELAENT pointers      208
RELASZ pointers      208
Relative addressing      155
Relative jumps      40
RELENT pointers      208
Relinkable formats and relocation      159—160
Relinkable formats, incremental      233—235
Relinkable formats, object      7
Relocatable text references      202
Relocation      5 149—165
Relocation and a.out files      58—62
Relocation and code modification      8—10
Relocation and DOS EXE files      56—58
Relocation and ELF files      62—68 158—159
Relocation and thread local storage      161—162
Relocation entries      13 56 59—60
Relocation information      48 92
Relocation information in program files      37
Relocation information, including with each library      40
Relocation of bitmaps      161
Relocation techniques      153—159
Relocation techniques, instruction relocation      154—157
Relocation techniques, segment relocation      157—158
Relocation, chained references      160—161
Relocation, defined      149
Relocation, ECOFF segment      157—158
Relocation, hardware      3—4
Relocation, hardware and software      150
Relocation, link-time      151
Relocation, load-time      151 168—169 212
Relocation, OMF      159
Relocation, output formats      159—160
Relocation, relinkable formats      159—160
Relocation, run-time      218
Relocation, special cases      162—163
Relocation, symbol and segment      151—153
RELSZ pointers      208
Resolution, lazy just-in-time      244
Resolution, symbol      5 58 123—124
Resources, in Microsoft Portable Executable (PE) format      82
Return instruction hardware      25
RISC architecture in UNIX systems      105
RISC architecture, decompiling object code      237
RISC chip design      10 22
RLD format      71 74
Root segments, loading      178
Rules about machine registers      20
Rules about memory addresses      20
Run-time binding      150
Run-time relocation      218
Runnable files      58 197—199
RVAs      81 218—220
Scratch registers      27
SD (section definition) type symbols      71
SECREL fixups      162
Section headers, for ELF files      65
Section table, for Microsoft Portable Executable (PE) format      80
Sections      see "Input segments"
SEGDEF records      86—87
Segment table, example      182
Segmented architectures      41—43 49
segments      6 see
Segments, aligning in storage allocation      96—98
Segments, bss      14
Segments, data      14
Segments, defined      41
Segments, input      111
Segments, loadable      69 111
Segments, manipulation code for      42
Segments, overriding      41
Segments, relocating      151—153 157—158
Segments, root      178
Segments, shuffling      114
Segments, storage allocation      93—94
Sequence calling      27
Sequential storage allocation      94
Set vectors      197
SETHI absolute address hack      156 158
SGI systems      224
shared libraries      39—40 187—204 see
Shared libraries, address space management in      190—191
Shared libraries, administering      40
Shared libraries, binding time      188—190
Shared libraries, creating      192—196
Shared libraries, ELF      175 209
Shared libraries, in multiple directories      196
Shared libraries, in practice      190
Shared libraries, linking with      197 226
Shared libraries, making fast      223—224
Shared libraries, malloc hack to      199—200
Shared libraries, pseudo-static      222—223
Shared libraries, running with      197—199
Shared libraries, space savings with      4
Shared libraries, static      4 17 189
Shared libraries, structure of      192
Shared libraries, version naming      196
Shared libraries, workings of      4 188
Shared object ELF files      62
Shared programs      39
Significant byte      21
Slim binaries      240
Small model code      42
Software relocation      3—4 150
SONAME files      208 216
source files      184
Source files in C programming language      13
SPARC architecture      23 30—32
SPARC architecture, branching in      160—161 163
SPARC architecture, data and instruction references      30—32 45
SPARC architecture, instruction formats      24
SPARC architecture, instruction relocation      155—157
SPARC architecture, V8      31—32
SPARC architecture, V9      32
Spike      239
stack frame      25—26
Stack pointers      25 33 57
startup code      14
static data      4 25—26
Static data, global      25—26
Static data, initializing      215—216
Static data, local      25—26
Static objects, addressing      26
Static shared libraries      4 17 189 see
Storage allocation      93—115
Storage allocation for global static data      25
Storage allocation for local static data      25
Storage allocation in a.out linkers      109—111
Storage allocation in ELF      111—113
Storage allocation in Microsoft PE linkers      113—114
Storage allocation in practice      108—114
Storage allocation, C++ duplicate removal      99—102
Storage allocation, common blocks      98—99
Storage allocation, heap management      143
Storage allocation, IBM pseudo-registers      103—105
Storage allocation, implementing in project      115
Storage allocation, initializers and finalizers      102—103
Storage allocation, linker control scripts      107—108
Storage allocation, multiple-segment types      96—98
Storage allocation, segment and page alignment      96—98
1 2 3 4
blank
Ðåêëàìà
blank
blank
HR
@Mail.ru
       © Ýëåêòðîííàÿ áèáëèîòåêà ïîïå÷èòåëüñêîãî ñîâåòà ìåõìàòà ÌÃÓ, 2004-2024
Ýëåêòðîííàÿ áèáëèîòåêà ìåõìàòà ÌÃÓ | Valid HTML 4.01! | Valid CSS! Î ïðîåêòå