Linux Assembly Programming

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

Halo Linux Services

» Linux Assembly Programming

Review

Popular Articles

Categories