- Flag Etiquette Bug to Beware Of
- Framework to Build On
- Jungle of Jump Instructions
- Minimal NASM Program
- Note on Capitalization Conventions
- Quick Insight Run Through
- Text Display Virtual Screen
- About the Author
- Acknowledgments
- Adding and Subtracting One with INC and DEC
- Adding Items to the Toolbar
- Addresses
- Adjusting AAAs Adjustments
- An Assembly Language Reference for Beginners
- An Interrupt That Doesnt Interrupt Anything
- Anatomy of the Linux Stack
- And Personal
- Are We There
- Assembler Errors
- Assembler Warnings
- Assembling the Source Code File
- Assembly Language
- Assembly Language Programming As a Board Game
- ATT Memory Reference Syntax
- ATT Mnemonic Conventions
- Back to the Editor
- Base Displacement Addressing
- Base Index Addressing
- Beware Write Only Source Code
- Binary Files vs Text Files
- Bit and 32Bit Registers
- Bit and 32bit Versions of STOS
- Bit Memory What May Be Possible Someday vs What We Can Do
- Bit Numbering
- Bit Bashing in Action
- Bits Is Bits and Bytes Is Bits
- Boxes within Boxes
- Build Yourself a Sandbox
- Building Code the GNU
- Building External Procedure Libraries
- Calling Conventions
- Calling and Returning
- Calls to Addresses in Registers
- Calls within Calls
- Chains of Dependencies
- Alien Bases
- Character Encoding in Konsole
- Character Set Charts
- Character Table Translation
- Characters Out via puts
- Closing the Inner Loop
- Closing the Outer Loop
- Code and Data
- Command Line Arguments and Examining the Stack
- Comments
- Comparisons with CMP
- Computers Think Like Us
- Conclusion Not the End But Only the Beginning
- Conditional Jumps
- Configuration
- Confusing Data and Its Address
- Console Control Cautions
- Contents at a Glance
- Converting a timet Value to a Formatted String
- Converting Strings into Numbers with sscanf
- Counting in Martian
- Creating and Opening Files
- Creating and Using Macros
- Creating Programs That Work
- Credits
- Data In with fgets and scanf
- Debuggers and Debugging
- Deciding What Should Be a Procedure
- Defining Lines in the Display Buffer
- Defining Macros with Parameters
- Defining the Problem
- Dependencies
- Deriving String Length with EQU and
- Designing a Non Trivial Program
- Destroying a Stack Frame
- DF and Overlapping Block Moves
- Direct Access to Port Hardware
- Direct Calls into the BIOS
- Discovering What Computers Actually
- Displacements
- Displaying a Ruler on the Screen
- Displaying an Ascii Table
- Dissecting a Martian Number
- Easing into Mainstream Assembly Coding
- Editing the Source Code File
- Effective Address Calculations
- Endianness
- Errors versus Bugs
- Examining gas Source Files Created by gcc
- Examining the Stack with Insights Memory View
- Executing the Stosb Instruction
- Exiting a Program via INT 80h
- Fetching timet Values from the System Clock
- Files and Whats Inside Them
- Five Hundred Plates per Hour
- Flag Etiquette
- Flag Results
- Flags - 2
- Flags Affected - 2 3
- Flags Tests and Branches
- For Extra Credit
- Forcing Local Label Access
- Formatted Text Output with printf
- General Purpose Registers
- Generating Pseudorandom Numbers
- Generating Random Numbers
- Generating Separate Local Time Values
- Getting Home Again
- Global and External Declarations
- Going Further
- Greater Than Versus Above
- Had This Been the Real Thing
- Hexadecimal Solving the Digit Shortage
- How Bit Shifting Works
- How C Sees Command Line Arguments
- How Flags Change Program Execution
- How to Use gcc in Assembly Work
- Immediate Data
- Implicit Operands and MUL
- Index
- Index x Scale Displacement Addressing
- Info - 2 3
- Insights Many Windows
- Installing Kate
- Instructions and Their Operands
- INT 80h and the Portability Fetish
- Interpreting Raw Data
- Invoking Make from Inside Kate
- IO Redirection
- Its All in the Plan
- Its the Logical Thing to Do
- Jumping on the Absence of a Condition
- Jumping When ECX Goes to
- Kate Sessions
- Kates Editing Controls
- Labels
- Language
- Last In First Out via the Stack
- Launching Kate
- Ld o eatsyscall eatsyscallo
- LEA The Top Secret Math Machine
- Legal Forms - 2 3 4 5 6 7 8 9 10 11 12 13 14 15
- Linker Errors
- Linking Libraries into Your Programs
- Linking the Object Code File
- Linking to the Standard C Library
- Linux and Terminals
- Local Data
- Local Labels and the Lengths of Jumps
- Local Labels Within Macros
- Looking Ahead 64Bit Long Mode
- Looking for 0 Bits with BT
- Looking for 1Bits with TEST
- M
- Machine Gunning the Virtual Display
- Macro Libraries As Include Files
- Macros versus Procedures Pros and Cons
- Maintainability and Reuse
- Making a Copy of glibcs tm Struct with MOVSD
- Masking Out Bits
- Memory Data
- Memory Joggers for Complex Memories
- Memory Mapped Video
- Metaphor Check
- More Table Tricks
- More Than Two Ways
- MOVSB Fast Block Copies
- MUL and the Carry Flag
- Multiplying by Shifting and Adding
- NASM f elf g F stabs
- Nested Instruction Loops
- NOT Logical NOT Ones Complement Flags Affected
- Notes - 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
- Notes on Gathering Your Procedures into Libraries 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
- Object Code and Linkers
- Octal How the Grinch Stole Eight and Nine
- Off By One Errors
- Operand Symbols
- Other Addressing Schemes
- Passing Parameters to printf
- Placing Constant Data in Procedure Definitions
- Playing Big
- POP Goes the Opcode
- Pop the Stack or Address It
- Procedures and the Data They Need
- Procedures As Boxes for Code
- Program Complexity
- Protected Mode Flat Model
- Protected Mode Memory Addressing in Detail
- Pushy Instructions
- Rally Round the Flags Boys
- Reading and Using an Assembly Language Reference
- Reading Text from Files with fgets
- Ready to Get Serious
- Real Mode Flat Model
- Real Mode Segmented Model
- Reference
- Register Data
- Register Halves
- Relocatability
- Rep Stosb the Software Machine
- ROL Rotate Left Flags Affected
- Rulers Lessons
- Running Insight
- Saving and Restoring Registers
- Saving the Callers Registers
- Scanning a Buffer
- Seeding the Generator with srand
- Segment Registers Dont Respond to Logic
- Sending the Buffer to the Linux Console
- Setting a Known Value into the Carry Flag
- Setting Command Line Arguments with Insight
- Setting Up a Stack Frame
- Shape the Way You Work
- Shifting Bits
- Shifting the High Nybble into the Low Nybble
- Short Near and Far Jumps
- Showchar Recap
- Sign Extension and MOVSX
- Signed and Unsigned Values
- Simple Cursor Control in the Linux Console
- Simple File IO
- Simple Text Filters
- Single Stepping REP String Instructions with Insight
- Software Interrupts versus Hardware Interrupts
- Some Bits Are More Random Than Others
- Source and Destination Operands
- Source Strings and Destination Strings
- Splitting a Byte into Two Nybbles
- Stacking Things Upside Down
- Starting with Pseudocode
- Step 1 Edit the Program in an Editor
- Step 2 Assemble the Program with NASM
- Step 3 Link the Program with LD
- Step 4 Test the Executable File
- Step 5 Watch It Run in the Debugger
- Step by Step
- Stepping off Square
- Steps and Tests
- Storage for the Short Term
- STOSB and the Direction Flag DF
- String Searches with SCASB
- String Variables
- Successive Refinement
- T
- Tables Instead of Calculations
- Taking a Trip Down Assembly Lane
- Terminal Control with Escape Sequences
- Testing the EXE File
- Text In Code
- The AND Instruction
- The Art of Crafting Procedures
- The Assembly Language Development Process
- The Bad Old Days
- The Bones of an Assembly Language Program
- The bss Section
- The Burden of 16Bit Registers
- The C Librarys Time Machine
- The Dangers of Accidental Recursion
- The Dangers of Too Many Procedures and Too Many Libraries
- The data Section
- The Discipline of Working Directories
- The Essence of a Number Base
- The Flags Register
- The Initial Comment Block
- The Insight Debugger
- The Instruction Pointer
- The Kate Editor
- The Linux Console
- The LOOP Instructions
- The Master Plan
- The Mechanics of Globals and Externals
- The Mechanics of Invoking Macros
- The Mechanics of Macro Definition
- The NOT Instruction
- The Notion of an Assembly Language String
- The OR Instruction
- The Return of the New Math Monster
- The Right to Assemble
- The Rotate Instructions
- The Semiautomatic Weapon STOSB without REP
- The Size of Memory Data
- The Swiss Army Compiler
- The text Section
- The Three Standard Unix Files
- The x86 Slowpokes
- The XOR Instruction
- Those Amazing String Instructions
- Those Inevitable Whoops Moments
- Translating with MOV or XLAT
- Translation Tables
- Turning Your String Sense Inside Out
- Twos Complement and NEG
- Unconditional Jumps
- Understanding ATT Instruction Mnemonics
- Unsigned Division with DIV
- Use Comment Headers
- Using a Lookup Table
- Using Linux Kernel Services Through INT80
- Using Linux Make
- Using Touch to Force a Build
- Variables for Initialized Data
- Virtual Memory in Two Chunks
- Watching Flags from Insight
- What Protected Mode Wont Let Us Do Anymore
- What Youll Need
- Whats Not Here
- When a File Is Up to Date
- Where Things
- Where to
- Who Decrements ECX
- Who Stole Eight and Nine
- Why Not gas
- Why Stack Addresses Arent Predictable
- Writing Text to Files with fprintf