search for books and compare prices
Tables of Contents for Assembly Language Step-By-Step
Chapter/Section Title
Page #
Page Count
Acknowledgments
xvii
Foreword
xix
Introduction
xxi
Another Pleasant Valley Saturday
1
14
It's All in the Plan
1
4
Steps and Tests
3
1
More than Two Ways?
3
2
Computers Think Like Us
5
1
Had This Been the Real Thing...
5
1
Do Not Pass Go
6
9
The Game of Big Bux
6
1
Playing Big Bux
7
2
Assembly Language Programming as a Board Game
9
2
Code and Data
11
1
Addresses
12
1
Metaphor Check!
12
3
Alien Bases
15
32
The Return of the New Math Monster
15
1
Counting in Martian
16
5
Dissecting a Martian Number
17
3
The Essence of a Number Base
20
1
Octal: How the Grinch Stole Eight and Nine
21
5
Who Stole Eight and Nine?
21
4
Living Fossils
25
1
Hexadecimal: Solving the Digit Shortage
26
2
From Hex to Decimal and from Decimal to Hex
28
6
From Hex to Decimal
29
2
From Decimal to Hex
31
2
Practice. Practice! Practice!
33
1
Arithmetic in Hex
34
6
Columns and Carries
36
1
Subtraction and Borrows
37
2
Borrows across Multiple Columns
39
1
What's the Point?
40
1
Binary
40
5
Values in Binary
42
2
Why Binary?
44
1
Hexadecimal as Shorthand for Binary
45
2
Prepare to Compute
46
1
Lifting the Hood
47
26
RAXie, We Hardly Knew Ye...
47
3
Gus to the Rescue
48
2
Switches, Transistors, and Memory
50
10
One if by Land...
50
1
Transistor Switches
51
2
The Incredible Shrinking Bit
53
2
Random Access
55
2
Memory Access Time
57
1
Bytes, Words, Double Words, and Quad Words
57
2
Pretty Chips All in a Row
59
1
The Shop Foreman and the Assembly Line
60
6
The Honcho Chip
61
2
Talking to Memory
63
1
Riding the Bus
64
1
The Foreman's Pockets
65
1
The Assembly Line
66
1
The Box That Follows a Plan
66
7
Fetch and Execute
67
1
The Foreman's Innards
68
2
Changing Course
70
1
The Plan
71
2
The Right to Assemble
73
46
Nude with Bruises and Other Perplexities
73
2
Sweet Blindness: The Software Components Conundrum
74
1
Dos and Dos files
75
9
The God Above, the Troll Below
76
1
Dos Files: Magnetic Memory
77
2
Binary Files
79
1
Text Files
79
1
Living Fossils
80
2
Text Editors
82
2
Compilers and Assemblers
84
10
Assembly Language
84
2
Comments
86
1
Beware ``Write-Only'' Source Code!
87
1
Object Code and Linkers
88
2
Executable Program Files
90
2
Setting Up a Working Directory
92
2
The Assembly Language Development Process
94
12
Assembling the Source Code File
96
1
Assembler Errors
96
2
Back to the Editor
98
1
Assembler Warnings
99
3
Linker Errors
102
1
Testing the .EXE File
103
1
Errors versus Bugs
104
1
Debuggers and Debugging
104
2
DEBUG and How to Use It
106
13
DEBUG's Bag of Tricks
106
2
Taking Debug for a Spin
108
1
Looking at a Hex Dump
108
3
Changing Memory with Debug
111
1
The Dangers of Modifying Files
112
2
Examining and Changing Registers
114
4
The Hacker's Best Friend
118
1
NASM-IDE: A Place to Stand
119
32
Access to Tools
119
2
Nasm-Ide
120
1
Nasm-Ide's Place to Stand
121
5
Telling Nasm-Ide Where Nasm Is
122
1
The Edit Window
123
1
The Menu Bar
124
1
The Prompt Bar
125
1
Other Windows
125
1
Using Nasm-Ide's Tools
126
7
Invoking Nasm-Ide
127
2
Moving Around the Edit Window
129
1
Making Changes to the File
129
1
Saving Changes to a File
130
1
Assembling the Current File
131
2
Running the Executable File
133
1
Nasm-Ide's Editor in Detail
133
15
Loading Files into the Editor
134
2
Moving the Cursor
136
1
One Character at a Time
137
1
One Word at a Time
138
1
One Screen at a Time
138
1
Moving the Cursor by Scrolling the Screen
138
1
Moving to the Ends of the Line
139
1
Moving to the Ends of the File
139
1
Insert Mode and Cursor Coordinates
139
1
The Indent Toggle
140
1
Deleting Text
141
1
Undoing Changes to a Line
142
1
Marking Text Blocks
142
1
The Clipboard and Block Commands
143
2
Searching for Text
145
1
Searching for Additional Instances
146
1
Replacing Found Text
147
1
Saving Your Work
148
1
Other Nasm-Ide Features
148
3
Exiting Nasm-Ide
149
1
Changing the Display Size
149
1
Dos Shell
150
1
An Uneasy Alliance
151
42
The Joy of Memory Models
151
9
16 Bits'll Buy You 64K
153
4
The Nature of a Megabyte
157
1
Backward Compatibility
158
1
16-Bit Blinders
159
1
The Nature of Segments
160
7
A Horizon, Not a Place
164
1
Making 20-Bit Addresses out of 16-Bit Registers
164
3
16-Bit and 32-Bit Registers
167
7
General-Purpose Registers
168
3
Register Halves
171
1
The Instruction Pointer
172
2
The Flags Register
174
1
The Three Major Assembly Programming Models
174
8
Real Mode Flat Model
175
2
Real Mode Segmented Model
177
3
Protected Mode Flat Model
180
2
Reading and Changing Registers with Debug
182
11
Inspecting the Video Refresh Buffer with Debug
184
4
Reading the Basic Input/Output System Revision Date
188
1
Transferring Control to Machine Instructions in Read-Only Memory
189
4
Following Your Instruction
193
34
Assembling and Executing Machine Instructions with Debug
194
4
Assembling a MOV Instruction
194
2
Executing a MOV Instruction with the Trace Command
196
2
Machine Instructions and Their Operands
198
12
Source and Destination Operands
198
1
Immediate Data
199
1
Register Data
200
2
Memory Data
202
1
BX's Hidden Agenda
203
1
Using Memory Data
204
1
Segment Register Assumptions
205
1
Overriding Segment Assumptions for Memory Data
205
2
Real Mode Memory Data Summary
207
1
Limitations of the MOV Instruction
207
2
Some Notes on Assembler Syntax
209
1
Reading and Using an Assembly Language Reference
210
7
Blue Cards
211
1
An Assembly Language Reference for Beginners
211
1
Flags
212
2
Legal Forms
214
1
Operand Symbols
215
1
Examples
215
1
Notes
216
1
What's Not Here...
216
1
Rally Round the Flags, Boys!
217
6
Check That Reference Page!
219
1
Adding and Subtracting One with INC and DEC
219
2
Using Debug to Watch the Flags
221
2
Using Type Specifiers
223
4
Types in Assembly Language
224
3
Our Object All Sublime
227
40
The Bones of an Assembly Language Program
228
9
The Simplicity of Flat Model
229
2
Labels
231
1
Variables for Initialized Data
232
1
String Variables
232
2
Directives versus Instruction Mnemonics
234
1
The Difference between a Variable's Address and Its Contents
235
1
Making Dos Calls
236
1
Exiting the Program and Setting Errorlevel
236
1
Assembling and Running EAT.ASM
237
3
Assembler and Internactive Development Environment
237
2
What Happens When a .COM File Runs
239
1
One Program, Three Segments
240
7
Three Segments
242
1
Don't Assume...
243
2
Naming the Stack Segment
245
1
Choosing a Starting Point
245
1
Assembling and Linking EATSEG.ASM
246
1
Last In, First Out via the Stack
247
8
Five Hundred Plates an Hour
247
1
An Upside-Down Segment
248
3
Pushing Data
251
2
POP Goes the Opcode
253
2
Storage for the Short Term
255
1
Using Dos Services through Int
255
12
An Interrupt That Doesn't Interrupt Anything
256
6
Getting Home Again
262
2
Software Interrupts versus Hardware Interrupts
264
3
Dividing and Conquering
267
48
Programming in Martian
267
1
Boxes within Boxes
268
8
Procedures as Boxes for Code
269
2
Calling and Returning
271
1
Calls within Calls
272
3
When to Make Something a Procedure
275
1
Using Bios Services
276
12
Positioning the Hardware Cursor
277
2
Using Video Service 6
279
1
Procedures with Multiple Entry Points
279
3
Memory Data or Immediate Data?
282
1
Use Comment Headers!
282
6
Building External Libraries of Procedures
288
13
Public and External Declarations
288
3
The Mechanics of Globals and Externals
291
5
Dividing a Segment across Module Boundaries
296
1
Your Main Program Module
296
3
Linking Multiple Modules
299
1
Batch Files for Building Modular Programs
300
1
External Module Summary
301
1
Creating and Using Macros
301
14
Macros versus Procedures: Pro and Con
302
2
The Mechanics of Macro Definition
304
1
Defining Macros with Parameters
305
1
The Mechanics of Macro Parameters
306
1
Local Labels within Macros
306
2
Macro Libraries
308
7
Bits, Flags, Branches, and Tables
315
54
Bits Is Bits (and Bytes Is Bits)
316
7
Bit Numbering
316
1
``It's the Logical Thing to Do, Jim...''
316
2
The and Instruction
318
1
Masking Out Bits
318
2
The OR Instruction
320
1
The XOR Instruction
320
322
The NOT Instruction
322
1
Segment Registers Don't Respond to Logic!
322
1
Shifting Bits
323
8
Shift by What?
323
1
How Bit Shifting Works
323
1
Bumping Bits into the Carry Flag
324
1
Byte2Str: Converting Numbers to Displayable Strings
324
2
Splitting a Byte into Two Nybbles
326
1
Using a Lookup Table
326
1
Shifting the High Nybble into the Low Nybble
327
2
Converting Words to Their String Form
329
2
Flags, Tests, and Branches
331
16
Unconditional Jumps
332
1
Conditional Jumps
332
1
Beware Endless Loops!
333
1
Jumping on the Absence of a Condition
334
1
Flags
335
1
Comparisons with CMP
336
1
A Jungle of Jump Instructions
336
1
Greater Than versus Above
337
2
Detecting the Installed Display Adapter
339
5
Testing Bits with TEST
344
1
The Phantoms of the Opcodes
344
2
TEST Pointers
346
1
Assembly Odds'n Ends
347
22
Yet Another Lookup Table
347
2
Using Shift Instructions to Multiply by Powers of Two
349
1
Tables within Tables
350
5
Base-Indexed-Displacement Memory Addressing
355
2
Finding the Number of Lines in the Screen
357
1
Equates and the Current Location Counter
358
11
Stringing Them Up
369
30
The Notion of an Assembly Language String
370
2
Turning Your ``String Sense'' Inside-Out
370
1
Source Strings and Destination Strings
371
1
REP STOSW, the Software Machine Gun
372
5
Machine-Gunning the Video Display Buffer
372
1
Executing the STOSW Instruction
373
2
STOSW and the Direction Flag DF
375
2
The Semiautomatic Weapon: STOSW without REP
377
10
Who Decrements CX?
377
1
The Loop Instructions
378
1
Displaying a Ruler on the Screen
379
1
Simple Multiplies with IMUL
380
2
The Limitations of Macro Arguments
382
2
Adding ASCII Digits
384
2
Adjusting AAA's Adjustments
386
1
Ruler's Lessons
387
1
Storing Data to Discontinuous Strings
387
12
Displaying an ASCII Table in a Big Hurry
388
1
The Nature of Equates
389
2
Assembly-Time Calculations
391
1
Nested Instruction Loops
392
1
Jumping When CX Goes to 0
393
1
Closing the Inner Loop
394
1
Closing the Outer Loop
395
1
SHOWCHAR.ASM Recap
396
1
The Other String Instructions
396
1
Further Research: Building Your Assembly Language Video Toolkit
397
2
The Programmer's View of Linux
399
52
Where to Now?
399
3
Why Not Windows?
400
1
And Why Linux?
401
1
Prerequisites---Yukkh!
402
3
Linux Is Not Dos!
403
1
EMACS: More than an Editor
404
1
It's a C World
405
1
NASM for Linux
405
3
Installing NASM's Source Code
406
1
Rebuilding NASM
407
1
What's GNU?
408
5
The Swiss Army Compiler
409
1
Building Code the GNU Way
409
3
How We Use gcc in Assembly Work
412
1
Why Not gas?
413
1
The make Utility and Dependencies
413
7
Dependencies
414
2
When a File Is Up to Date
416
1
Chains of Dependencies
417
2
Using make from within EMACS
419
1
Understanding AT&T Instruction Mnemonics
420
7
Examining gas Source Files Created by gcc
423
2
AT&T Memory Reference Syntax
425
2
Using the GNU Debugger
427
21
Your Code, My Code, and Our Code
427
2
Spotting Symbols in an Executable File
429
2
Stripping Symbols out of an Executable File
431
1
Loading a Program for Debugging
432
1
Setting Breakpoints in gdb
433
3
Providing Command-Line Arguments
436
1
Examining Registers
437
1
Examining Program Variables and Individual Registers
438
4
Changing Register and Program Variable Values
442
1
Single-Stepping Your Programs
443
5
Your Work Strategy
448
3
Put Only One Project in One Directory
448
1
Consider EMACS Home
449
1
Opening a Shell from inside EMACS
450
1
Coding for Linux
451
80
Genuflecting to the C Culture
452
3
The Primacy of Libraries
452
1
The INT 80H Kernel Function Interface
453
1
C Calling Conventions
454
1
A Framework to Build On
455
6
Saving and Restoring Registers
457
1
Setting Up a Stack Frame
458
2
Destroying a Stack Frame
460
1
The Perks of Protected Mode
461
8
You Know Have a 386 or Better
461
1
No Segments!
461
1
More Versatile Registers and Addressing
462
2
More Instructions
464
3
Crash Protection
467
2
Characters Out
469
7
The Three Standard Files
471
1
Formatted Text with printf
472
2
Passing Arguments to printf
474
2
Characters In
476
6
String Input with fgets
476
2
Using scanf for Entry of Numeric Values
478
4
Be a Time Lord
482
9
The C Library's Time Machine
482
1
Fetching time_t Values from the System Clock
483
1
Converting a time_t Value to a Formatted String
484
1
Generating Separate Local Time Values
485
1
Uninitialized Storage and [.bss]
486
1
Making a Copy of clib's tm Struct with MOVSD
487
4
Generating Random Numbers
491
13
Seeding the Generator with srand
492
1
Generating Pseudorandom Numbers
493
4
Some Bits Are More Random than Others
497
2
Calls to Addresses in Registers
499
1
Local Labels
500
3
Placing Constant Data in a Subroutine
503
1
Accessing Command-Line Arguments
504
5
Addressing the Stack Relative to EBP
505
1
Scaled Addressing
506
3
Simple File I/O
509
16
Converting Strings into Numbers with sscanf
510
1
Creating and Opening Files
511
2
Reading Text from Files with fgets
513
3
Writing Text to Files with fprintf
516
2
Gathering Your Subroutines into Libraries
518
7
Conclusion Not the End, But Only the Beginning
525
6
Where to Now?
527
2
Stepping off Square One
529
2
Appendix A Partial 8086/8088 Instruction Set Reference
531
64
Appendix B Segment Register Assumptions for Real Mode Segmented Model
595
2
Appendix C Web URLs for Assembly Programmers
597
2
Appendix D Segment Register Assumptions
599
2
Appendix E What's on the CD-ROM?
601
2
Index
603