book

Assembly Language Step-by-Step: Programming with Linux®, Third Edition

Name: Assembly Language Step-by-Step: Programming with Linux®, Third Edition
Author: Jeff Duntemann
ISBN: 9780470497029

by Jeff Duntemann

October 2009

Beginner

648 pages

16h 11m

English

Wiley

Read now

Unlock full access

Copyright
About the Author
Credits
Acknowledgments
Introduction: "Why Would You Want to Do That?"
What You'll NeedThe Master PlanA Note on Capitalization ConventionsWhy Am I Here Again?
1. Another Pleasant Valley Saturday
1.1. It's All in the Plan1.1.1. Steps and Tests1.1.2. More Than Two Ways?1.1.3. Computers Think Like Us1.2. Had This Been the Real Thing...1.3. Do Not Pass Go1.3.1. The Game of Big Bux1.3.2. Playing Big Bux1.4. Assembly Language Programming As a Board Game1.4.1. Code and Data1.4.2. Addresses1.4.3. Metaphor Check!
2. Alien Bases
2.1. The Return of the New Math Monster2.2. Counting in Martian2.2.1. Dissecting a Martian Number2.2.2. The Essence of a Number Base2.3. Octal: How the Grinch Stole Eight and Nine2.3.1. Who Stole Eight and Nine?2.4. Hexadecimal: Solving the Digit Shortage2.5. From Hex to Decimal and from Decimal to Hex2.5.1. From Hex to Decimal2.5.2. From Decimal to Hex2.5.3. Practice. Practice! PRACTICE!2.6. Arithmetic in Hex2.6.1. Columns and Carries2.6.2. Subtraction and Borrows2.6.3. Borrows across Multiple Columns2.6.4. What's the Point?2.7. Binary2.7.1. Values in Binary2.7.2. Why Binary?2.8. Hexadecimal As Shorthand for Binary2.8.1. Prepare to Compute
3. Lifting the Hood
3.1. RAXie, We Hardly Knew Ye...3.1.1. Gus to the Rescue3.2. Switches, Transistors, and Memory3.2.1. One If by Land...3.2.2. Transistor Switches3.2.3. The Incredible Shrinking Bit3.2.4. Random Access3.2.5. Memory Access Time3.2.6. Bytes, Words, Double Words, and Quad Words3.2.7. Pretty Chips All in a Row3.3. The Shop Foreman and the Assembly Line3.3.1. Talking to Memory3.3.2. Riding the Data Bus3.3.3. The Foreman's Pockets3.3.4. The Assembly Line3.4. The Box That Follows a Plan3.4.1. Fetch and Execute3.4.2. The Foreman's Innards3.4.3. Changing Course3.5. What vs. How: Architecture and Microarchitecture3.5.1. Evolving Architectures3.5.2. The Secret Machinery in the Basement3.6. Enter the Plant Manager3.6.1. Operating Systems: The Corner Office3.6.2. BIOS: Software, Just Not as Soft3.6.3. Multitasking Magic3.6.4. Promotion to Kernel3.6.5. The Core Explosion3.6.6. The Plan
4. Location, Location, Location
4.1. The Joy of Memory Models4.1.1. 16 Bits'll Buy You 64K4.1.2. The Nature of a Megabyte4.1.3. Backward Compatibility and Virtual 86 Mode4.1.4. 16-Bit Blinders4.2. The Nature of Segments4.2.1. A Horizon, Not a Place4.2.2. Making 20-Bit Addresses out of 16-Bit Registers4.3. 16-Bit and 32-Bit Registers4.3.1. General-Purpose Registers4.3.2. Register Halves4.3.3. The Instruction Pointer4.3.4. The Flags Register4.4. The Three Major Assembly Programming Models4.4.1. Real Mode Flat Model4.4.2. Real Mode Segmented Model4.4.3. Protected Mode Flat Model4.5. What Protected Mode Won't Let Us Do Anymore4.5.1. Memory-Mapped Video4.5.2. Direct Access to Port Hardware4.5.3. Direct Calls into the BIOS4.6. Looking Ahead: 64-Bit "Long Mode"4.6.1. 64-Bit Memory: What May Be Possible Someday vs. What We Can Do Now
5. The Right to Assemble
5.1. Files and What's Inside Them5.1.1. Binary Files vs. Text Files5.1.2. Looking at File Internals with the Bless Editor5.1.3. Interpreting Raw Data5.1.4. "Endianness"5.2. Text In, Code Out5.2.1. Assembly Language5.2.2. Comments5.2.3. Beware "Write-Only" Source Code!5.2.4. Object Code and Linkers5.2.5. Relocatability5.3. The Assembly Language Development Process5.3.1. The Discipline of Working Directories5.3.2. Editing the Source Code File5.3.3. Assembling the Source Code File5.3.4. Assembler Errors5.3.5. Back to the Editor5.3.6. Assembler Warnings5.3.7. Linking the Object Code File5.3.8. Linker Errors5.3.9. Testing the .EXE File5.3.10. Errors versus Bugs5.3.11. Are We There Yet?5.3.12. Debuggers and Debugging5.4. Taking a Trip Down Assembly Lane5.4.1. Installing the Software5.4.2. Step 1: Edit the Program in an Editor5.4.3. Step 2: Assemble the Program with NASM5.4.4. Step 3: Link the Program with LD5.4.5. Step 4: Test the Executable File5.4.6. Step 5: Watch It Run in the Debugger5.4.7. Ready to Get Serious?

6. A Place to Stand, with Access to Tools
6.1. The Kate Editor6.1.1. Installing Kate6.1.2. Launching Kate6.1.3. Configuration6.1.4. Kate Sessions6.1.4.1. Creating a New Session6.1.4.2. Opening an Existing Session6.1.4.3. Deleting or Renaming Sessions6.1.5. Kate's File Management6.1.5.1. Filesystem Browser Navigation6.1.5.2. Adding a File to the Current Session6.1.5.3. Dropping a File from the Current Session6.1.5.4. Switching Between Session Files in the Editor6.1.5.5. Creating a Brand-New File6.1.5.6. Creating a Brand-New Folder on Disk6.1.5.7. Deleting a File from Disk (Move File to Trash)6.1.5.8. Reloading a File from Disk6.1.5.9. Saving All Unsaved Changes in Session Files6.1.5.10. Printing the File in the Editor Window6.1.5.11. Exporting a File As HTML6.1.6. Adding Items to the Toolbar6.1.7. Kate's Editing Controls6.1.7.1. Cursor Movement6.1.7.2. Bookmarks6.1.7.3. Selecting Text6.1.7.4. Searching the Text6.1.7.5. Using Search and Replace6.1.8. Using Kate While Programming6.1.8.1. Creating and Using Project Directories6.1.8.2. Focus!6.2. Linux and Terminals6.2.1. The Linux Console6.2.2. Character Encoding in Konsole6.2.3. The Three Standard Unix Files6.2.4. I/O Redirection6.2.5. Simple Text Filters6.2.6. Terminal Control with Escape Sequences6.2.7. So Why Not GUI Apps?6.3. Using Linux Make6.3.1. Dependencies6.3.2. When a File Is Up to Date6.3.3. Chains of Dependencies6.3.4. Invoking Make from Inside Kate6.3.5. Using Touch to Force a Build6.4. The Insight Debugger6.4.1. Running Insight6.4.2. Insight's Many Windows6.4.3. A Quick Insight Run-Through6.4.4. Pick Up Your Tools...
7. Following Your Instructions
7.1. Build Yourself a Sandbox7.1.1. A Minimal NASM Program7.2. Instructions and Their Operands7.2.1. Source and Destination Operands7.2.2. Immediate Data7.2.3. Register Data7.2.4. Memory Data7.2.5. Confusing Data and Its Address7.2.6. The Size of Memory Data7.2.7. The Bad Old Days7.3. Rally Round the Flags, Boys!7.3.1. Flag Etiquette7.3.2. Adding and Subtracting One with INC and DEC7.3.3. Watching Flags from Insight7.3.4. How Flags Change Program Execution7.4. Signed and Unsigned Values7.4.1. Two's Complement and NEG7.4.2. Sign Extension and MOVSX7.5. Implicit Operands and MUL7.5.1. MUL and the Carry Flag7.5.2. Unsigned Division with DIV7.5.3. The x86 Slowpokes7.6. Reading and Using an Assembly Language Reference7.6.1. Memory Joggers for Complex Memories7.6.2. An Assembly Language Reference for Beginners7.6.3. Flags7.7. NEG: Negate (Two's Complement; i.e., Multiply by −1)7.7.1. Flags Affected7.7.2. Legal Forms7.7.3. Examples7.7.4. Notes7.7.5. Legal Forms7.7.6. Operand Symbols7.7.7. Examples7.7.8. Notes7.7.9. What's Not Here...
8. Our Object All Sublime
8.1. The Bones of an Assembly Language Program8.1.1. The Initial Comment Block8.1.2. The .data Section8.1.3. The .bss Section8.1.4. The .text Section8.1.5. Labels8.1.6. Variables for Initialized Data8.1.7. String Variables8.1.8. Deriving String Length with EQU and $8.2. Last In, First Out via the Stack8.2.1. Five Hundred Plates per Hour8.2.2. Stacking Things Upside Down8.2.3. Push-y Instructions8.2.4. POP Goes the Opcode8.2.5. Storage for the Short Term8.3. Using Linux Kernel Services Through INT808.3.1. An Interrupt That Doesn't Interrupt Anything8.3.2. Getting Home Again8.3.3. Exiting a Program via INT 80h8.3.4. Software Interrupts versus Hardware Interrupts8.3.5. INT 80h and the Portability Fetish8.4. Designing a Non-Trivial Program8.4.1. Defining the Problem8.4.2. Starting with Pseudo-code8.4.3. Successive Refinement8.4.4. Those Inevitable "Whoops!" Moments8.4.5. Scanning a Buffer8.4.6. "Off By One" Errors8.4.7. Going Further
9. Bits, Flags, Branches, and Tables
9.1. Bits Is Bits (and Bytes Is Bits)9.1.1. Bit Numbering9.1.2. "It's the Logical Thing to Do, Jim..."9.1.3. The AND Instruction9.1.4. Masking Out Bits9.1.5. The OR Instruction9.1.6. The XOR Instruction9.1.7. The NOT Instruction9.1.8. Segment Registers Don't Respond to Logic!9.2. Shifting Bits9.2.1. Shift By What?9.2.2. How Bit Shifting Works9.2.3. Bumping Bits into the Carry Flag9.2.4. The Rotate Instructions9.2.5. Setting a Known Value into the Carry Flag9.3. Bit-Bashing in Action9.3.1. Splitting a Byte into Two Nybbles9.3.2. Shifting the High Nybble into the Low Nybble9.3.3. Using a Lookup Table9.3.4. Multiplying by Shifting and Adding9.4. Flags, Tests, and Branches9.4.1. Unconditional Jumps9.4.2. Conditional Jumps9.4.3. Jumping on the Absence of a Condition9.4.4. Flags9.4.5. Comparisons with CMP9.4.6. A Jungle of Jump Instructions9.4.7. "Greater Than" Versus "Above"9.4.8. Looking for 1-Bits with TEST9.4.9. Looking for 0 Bits with BT9.5. Protected Mode Memory Addressing in Detail9.5.1. Effective Address Calculations9.5.2. Displacements9.5.3. Base + Displacement Addressing9.5.4. Base + Index Addressing9.5.5. Index × Scale + Displacement Addressing9.5.6. Other Addressing Schemes9.5.7. LEA: The Top-Secret Math Machine9.5.8. The Burden of 16-Bit Registers9.6. Character Table Translation9.6.1. Translation Tables9.6.2. Translating with MOV or XLAT9.7. Tables Instead of Calculations
10. Dividing and Conquering
10.1. Boxes within Boxes10.1.1. Procedures As Boxes for Code10.2. Calling and Returning10.2.1. Calls within Calls10.2.2. The Dangers of Accidental Recursion10.2.3. A Flag Etiquette Bug to Beware Of10.2.4. Procedures and the Data They Need10.2.5. Saving the Caller's Registers10.2.6. Local Data10.2.7. More Table Tricks10.2.8. Placing Constant Data in Procedure Definitions10.3. Local Labels and the Lengths of Jumps10.3.1. "Forcing" Local Label Access10.3.2. Short, Near, and Far Jumps10.4. Building External Procedure Libraries10.4.1. Global and External Declarations10.4.2. The Mechanics of Globals and Externals10.4.3. Linking Libraries into Your Programs10.4.4. The Dangers of Too Many Procedures and Too Many Libraries10.5. The Art of Crafting Procedures10.5.1. Maintainability and Reuse10.5.2. Deciding What Should Be a Procedure10.5.3. Use Comment Headers!10.6. Simple Cursor Control in the Linux Console10.6.1. Console Control Cautions10.7. Creating and Using Macros10.7.1. The Mechanics of Macro Definition10.7.2. Defining Macros with Parameters10.7.3. The Mechanics of Invoking Macros10.7.4. Local Labels Within Macros10.7.5. Macro Libraries As Include Files10.7.6. Macros versus Procedures: Pros and Cons
11. Strings and Things
11.1. The Notion of an Assembly Language String11.1.1. Turning Your "String Sense" Inside-Out11.1.2. Source Strings and Destination Strings11.1.3. A Text Display Virtual Screen11.2. REP STOSB, the Software Machine Gun11.2.1. Machine-Gunning the Virtual Display11.2.2. Executing the STOSB Instruction11.2.3. STOSB and the Direction Flag (DF)11.2.4. Defining Lines in the Display Buffer11.2.5. Sending the Buffer to the Linux Console11.3. The Semiautomatic Weapon: STOSB without REP11.3.1. Who Decrements ECX?11.3.2. The LOOP Instructions11.3.3. Displaying a Ruler on the Screen11.3.4. MUL Is Not IMUL11.3.5. Adding ASCII Digits11.3.6. Adjusting AAA's Adjustments11.3.7. Ruler's Lessons11.3.8. 16-bit and 32-bit Versions of STOS11.4. MOVSB: Fast Block Copies11.4.1. DF and Overlapping Block Moves11.4.2. Single-Stepping REP String Instructions with Insight11.5. Storing Data to Discontinuous Strings11.5.1. Displaying an ASCII Table11.5.2. Nested Instruction Loops11.5.3. Jumping When ECX Goes to 011.5.4. Closing the Inner Loop11.5.5. Closing the Outer Loop11.5.6. Showchar Recap11.6. Command-Line Arguments and Examining the Stack11.6.1. Virtual Memory in Two Chunks11.6.2. Anatomy of the Linux Stack11.6.3. Why Stack Addresses Aren't Predictable11.6.4. Setting Command-Line Arguments with Insight11.6.5. Examining the Stack with Insight's Memory View11.7. String Searches with SCASB11.7.1. REPNE vs. REPE11.7.2. Pop the Stack or Address It?11.7.3. For Extra Credit...
12. Heading Out to C
12.1. What's GNU?12.1.1. The Swiss Army Compiler12.1.2. Building Code the GNU Way12.1.3. How to Use gcc in Assembly Work12.1.4. Why Not gas?12.2. Linking to the Standard C Library12.2.1. C Calling Conventions12.2.2. A Framework to Build On12.2.3. Saving and Restoring Registers12.2.4. Setting Up a Stack Frame12.2.5. Destroying a Stack Frame12.2.6. Characters Out via puts()12.3. Formatted Text Output with printf()12.3.1. Passing Parameters to printf()12.4. Data In with fgets() and scanf()12.4.1. Using scanf() for Entry of Numeric Values12.5. Be a Time Lord12.5.1. The C Library's Time Machine12.5.2. Fetching time_t Values from the System Clock12.5.3. Converting a time_t Value to a Formatted String12.5.4. Generating Separate Local Time Values12.5.5. Making a Copy of glibc's tm Struct with MOVSD12.6. Understanding AT&T Instruction Mnemonics12.6.1. AT&T Mnemonic Conventions12.6.2. Examining gas Source Files Created by gcc12.6.3. AT&T Memory Reference Syntax12.7. Generating Random Numbers12.7.1. Seeding the Generator with srand()12.7.2. Generating Pseudorandom Numbers12.7.3. Some Bits Are More Random Than Others12.7.4. Calls to Addresses in Registers12.8. How C Sees Command-Line Arguments12.9. Simple File I/O12.9.1. Converting Strings into Numbers with sscanf()12.9.2. Creating and Opening Files12.9.3. Reading Text from Files with fgets()12.9.4. Writing Text to Files with fprintf()12.9.5. Notes on Gathering Your Procedures into Libraries
Conclusion: Not the End, But Only the Beginning
Where to Now?Stepping off Square One
A. Partial x86 Instruction Set Reference
A.1. Notes on the Instruction Set ReferenceA.1.1. Instruction OperandsA.1.2. Flag ResultsA.2. AAA: Adjust AL after BCD AdditionA.2.1. Flags AffectedA.2.2. Legal FormsA.2.3. ExamplesA.2.4. NotesA.3. ADC: Arithmetic Addition with CarryA.3.1. Flags AffectedA.3.2. Legal FormsA.3.3. ExamplesA.3.4. NotesA.4. ADD: Arithmetic AdditionA.4.1. Flags AffectedA.4.2. Legal FormsA.4.3. ExamplesA.4.4. NotesA.5. AND: Logical ANDA.5.1. Flags AffectedA.5.2. Legal FormsA.5.3. ExamplesA.5.4. NotesA.6. BT: Bit TestA.6.1. Flags AffectedA.6.2. Legal FormsA.6.3. ExamplesA.6.4. NotesA.7. CALL: Call ProcedureA.7.1. Flags AffectedA.7.2. Legal FormsA.7.3. ExamplesA.7.4. NotesA.8. CLC: Clear Carry Flag (CF)A.8.1. Flags AffectedA.8.2. Legal FormsA.8.3. ExamplesA.8.4. NotesA.9. CLD: Clear Direction Flag (DF)A.9.1. Flags AffectedA.9.2. Legal FormsA.9.3. ExamplesA.9.4. NotesA.10. CMP: Arithmetic ComparisonA.10.1. Flags AffectedA.10.2. Legal FormsA.10.3. ExamplesA.10.4. NotesA.11. DEC: Decrement OperandA.11.1. Flags AffectedA.11.2. Legal FormsA.11.3. ExamplesA.11.4. NotesA.12. DIV: Unsigned Integer DivisionA.12.1. Flags AffectedA.12.2. Legal FormsA.12.3. ExamplesA.12.4. NotesA.13. INC: Increment OperandA.13.1. Flags AffectedA.13.2. Legal FormsA.13.3. ExamplesA.13.4. NotesA.14. INT: Software InterruptA.14.1. Flags AffectedA.14.2. Legal FormsA.14.3. ExamplesA.14.4. NotesA.15. IRET: Return from InterruptA.15.1. Flags AffectedA.15.2. Legal FormsA.15.3. ExamplesA.15.4. NotesA.16. J?: Jump on ConditionA.16.1. Flags AffectedA.16.2. ExamplesA.16.3. NotesA.17. JCXZ: Jump If CX = 0A.17.1. Flags AffectedA.17.2. Legal FormsA.17.3. ExamplesA.17.4. NotesA.18. JECXZ: Jump If ECX = 0A.18.1. Flags AffectedA.18.2. Legal FormsA.18.3. ExamplesA.18.4. NotesA.19. JMP: Unconditional JumpA.19.1. Flags AffectedA.19.2. Legal FormsA.19.3. ExamplesA.19.4. NotesA.20. LEA: Load Effective AddressA.20.1. Flags AffectedA.20.2. Legal FormsA.20.3. ExamplesA.20.4. NotesA.21. LOOP: Loop until CX/ECX = 0A.21.1. Flags AffectedA.21.2. Legal FormsA.21.3. ExamplesA.21.4. NotesA.22. LOOPNZ/LOOPNE: Loop While CX/ECX > 0 and ZF = 0A.22.1. Flags AffectedA.22.2. Legal FormsA.22.3. ExamplesA.22.4. NotesA.23. LOOPZ/LOOPE: Loop While CX/ECX > 0 and ZF = 1A.23.1. Flags AffectedA.23.2. Legal FormsA.23.3. ExamplesA.23.4. NotesA.24. MOV: Move (Copy) Right Operand into Left OperandA.24.1. Flags AffectedA.24.2. Legal FormsA.24.3. ExamplesA.24.4. NotesA.25. MOVS: Move StringA.25.1. Flags AffectedA.25.2. Legal FormsA.25.3. ExamplesA.25.4. NotesA.26. MOVSX: Move (Copy) with Sign ExtensionA.26.1. Flags AffectedA.26.2. Legal FormsA.26.3. ExamplesA.26.4. NotesA.27. MUL: Unsigned Integer MultiplicationA.27.1. Flags AffectedA.27.2. Legal FormsA.27.3. ExamplesA.27.4. NotesA.28. NEG: Negate (Two's Complement; i.e., Multiply by −1)A.28.1. Flags AffectedA.28.2. Legal FormsA.28.3. ExamplesA.28.4. NotesA.29. NOP: No OperationA.29.1. Flags AffectedA.29.2. Legal FormsA.29.3. ExamplesA.29.4. NotesA.30. NOT: Logical NOT (One's Complement)A.30.1. Flags AffectedA.30.2. Legal FormsA.30.3. ExamplesA.30.4. NotesA.31. OR: Logical ORA.31.1. Flags AffectedA.31.2. Legal FormsA.31.3. ExamplesA.31.4. NotesA.32. POP: Pop Top of Stack into OperandA.32.1. Flags AffectedA.32.2. Legal FormsA.32.3. ExamplesA.32.4. NotesA.33. POPA/POPAD: Pop All GP RegistersA.33.1. Flags AffectedA.33.2. Legal FormsA.33.3. ExamplesA.33.4. NotesA.34. POPF: Pop Top of Stack into 16-Bit FlagsA.34.1. Flags AffectedA.34.2. Legal FormsA.34.3. ExamplesA.34.4. NotesA.35. POPFD: Pop Top of Stack into EFlagsA.35.1. Flags AffectedA.35.2. Legal FormsA.35.3. ExamplesA.35.4. NotesA.36. PUSH: Push Operand onto Top of StackA.36.1. Flags AffectedA.36.2. Legal FormsA.36.3. ExamplesA.36.4. NotesA.37. PUSHA: Push All 16-Bit GP RegistersA.37.1. Flags AffectedA.37.2. Legal FormsA.37.3. ExamplesA.37.4. NotesA.38. PUSHAD: Push All 32-Bit GP RegistersA.38.1. Flags AffectedA.38.2. Legal FormsA.38.3. ExamplesA.38.4. NotesA.39. PUSHF: Push 16-Bit Flags onto StackA.39.1. Flags AffectedA.39.2. Legal FormsA.39.3. ExamplesA.39.4. NotesA.40. PUSHFD: Push 32-Bit EFlags onto StackA.40.1. Flags AffectedA.40.2. Legal FormsA.40.3. ExamplesA.40.4. NotesA.41. RET: Return from ProcedureA.41.1. Flags AffectedA.41.2. Legal FormsA.41.3. ExamplesA.41.4. NotesA.42. ROL: Rotate LeftA.42.1. Flags AffectedA.42.2. Legal FormsA.42.3. ExamplesA.42.4. NotesA.43. ROR: Rotate RightA.43.1. Flags AffectedA.43.2. Legal FormsA.43.3. ExamplesA.43.4. NotesA.44. SBB: Arithmetic Subtraction with BorrowA.44.1. Flags AffectedA.44.2. Legal FormsA.44.3. ExamplesA.44.4. NotesA.45. SHL: Shift LeftA.45.1. Flags AffectedA.45.2. Legal FormsA.45.3. ExamplesA.45.4. NotesA.46. SHR: Shift RightA.46.1. Flags AffectedA.46.2. Legal FormsA.46.3. ExamplesA.46.4. NotesA.47. STC: Set Carry Flag (CF)A.47.1. Flags AffectedA.47.2. Legal FormsA.47.3. ExamplesA.47.4. NotesA.48. STD: Set Direction Flag (DF)A.48.1. Flags AffectedA.48.2. Legal FormsA.48.3. ExamplesA.48.4. NotesA.49. STOS: Store StringA.49.1. Flags AffectedA.49.2. Legal FormsA.49.3. ExamplesA.49.4. NotesA.50. SUB: Arithmetic SubtractionA.50.1. Flags AffectedA.50.2. Legal FormsA.50.3. ExamplesA.50.4. NotesA.51. XCHG: Exchange OperandsA.51.1. Flags AffectedA.51.2. Legal FormsA.51.3. ExamplesA.51.4. NotesA.52. XLAT: Translate Byte via TableA.52.1. Flags AffectedA.52.2. Legal FormsA.52.3. ExamplesA.52.4. NotesA.53. XOR: Exclusive OrA.53.1. Flags AffectedA.53.2. Legal FormsA.53.3. ExamplesA.53.4. Notes
B. Character Set Charts

Content preview from Assembly Language Step-by-Step: Programming with Linux®, Third Edition

Chapter 11. Strings and Things

Those Amazing String Instructions

At this point in the book we've touched on most of the important facets of assembly language work, including nearly all categories of machine instruction. One category remains, and for my money they're probably the most fascinating of all: the x86 string instructions.

They alone, of all the instructions in the x86 instruction set, have the power to deal with long sequences of bytes, words, or double words in memory at one time. (In assembly language, any contiguous sequence of bytes in memory may be considered a string—not simply sequences of human-readable characters.) More amazingly, some string instructions have the power to deal with these large sequences of bytes in an extraordinarily compact way: by executing a complete instruction loop as a single instruction, entirely within the CPU.

In this chapter, we'll cozy up to assembly language strings, and cover a few more topics related to programming and debugging for Linux.

The Notion of an Assembly Language String

Words fail us sometimes by picking up meanings as readily as a magnet picks up iron filings. The word string is a major offender here. It means roughly the same thing in all computer programming, but there are a multitude of small variations on that single theme. If you learned about strings in Pascal (as I did), you'll find that what you know isn't totally applicable when you program in C/C++, Python, Basic, or (especially) assembly.

So here's the Big View: ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

x64 Assembly Language Step-by-Step, 4th Edition

Publisher Resources

ISBN: 9780470497029Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Assembly Language Step-by-Step: Programming with Linux®, Third Edition

by Jeff Duntemann