John Wiley & Sons x64 Assembly Language Step-by-Step Cover The long-awaited x64 edition of the bestselling introduction to Intel assembly language In the newl.. Product #: 978-1-394-15524-8 Regular price: $57.85 $57.85 In Stock

x64 Assembly Language Step-by-Step

Programming with Linux

Duntemann, Jeff

Tech Today


4. Edition October 2023
640 Pages, Hardcover

ISBN: 978-1-394-15524-8
John Wiley & Sons

Buy now

Price: 61,90 €

Price incl. VAT, excl. Shipping

Further versions


The long-awaited x64 edition of the bestselling introduction to Intel assembly language

In the newly revised fourth edition of x64 Assembly Language Step-by-Step: Programming with Linux, author Jeff Duntemann delivers an extensively rewritten introduction to assembly language with a strong focus on 64-bit long-mode Linux assembler. The book offers a lighthearted, robust, and accessible approach to a challenging technical discipline, giving you a step-by-step path to learning assembly code that's engaging and easy to read.

x64 Assembly Language Step-by-Step makes quick work of programmable computing basics, the concepts of binary and hexadecimal number systems, the Intel x86/x64 computer architecture, and the process of Linux software development to dive deep into the x64 instruction set, memory addressing, procedures, macros, and interface to the C-language code libraries on which Linux is built.

You'll also find:
* A set of free and open-source development and debugging tools you can download and put to use immediately
* Numerous examples woven throughout the book to illustrate the practical implementation of the ideas discussed within
* Practical tips on software design, coding, testing, and debugging

A one-stop resource for aspiring and practicing Intel assembly programmers, the latest edition of this celebrated text provides readers with an authoritative tutorial approach to x64 technology that's ideal for self-paced instruction.

Introduction xxix

Chapter 1 It's All in the Plan 1

Another Pleasant Valley Saturday 1

Had This Been the Real Thing 5

Assembly Language Programming As a Square Dance 5

Assembly Language Programming As a Board Game 6

Chapter 2 Alien Bases 11

The Return of the New Math Monster 11

Octal: How the Grinch Stole Eight and Nine 16

Hexadecimal: Solving the Digit Shortage 20

From Hex to Decimal and from Decimal to Hex 24

Practice. Practice! PRACTICE! 27

Arithmetic in Hex 28

Binary 34

Hexadecimal as Shorthand for Binary 38

Prepare to Compute 40

Chapter 3 Lifting the Hood 41

RAXie, We Hardly Knew Ye 41

Switches, Transistors, and Memory 43

The Shop Supervisor and the Assembly Line 54

The Box That Follows a Plan 58

What vs. How: Architecture and Microarchitecture 63

Enter the Plant Manager 67

Chapter 4 Location, Location, Location 73

The Joy of Memory Models 73

The Nature of Segments 80

Segment Registers 87

The Four Major Assembly Programming Models 95

64-Bit Long Mode 101

Chapter 5 The Right to Assemble 103

The Nine and Sixty Ways to Code 103

Files and What's Inside Them 104

Text In, Code Out 115

The Assembly Language Development Process 123

Linking the Object Code File 130

Taking a Trip Down Assembly Lane 134

Chapter 6 A Place to Stand, with Access to Tools 143

Integrated Development Environments 143

Introducing SASM 146

Linux and Terminals 153

Using Linux Make 164

Debugging with SASM 172

Chapter 7 Following Your Instructions 175

Build Yourself a Sandbox 176

Instructions and Their Operands 178

Source and Destination Operands 178

Rally Round the Flags, Boys! 186

Signed and Unsigned Values 195

Implicit Operands and MUL 200

Reading and Using an Assembly Language Reference 205

NEG Negate (Two's Complement; i.e., Multiply by .1) 208

Chapter 8 Our Object All Sublime 213

The Bones of an Assembly Language Program 213

Last In, First Out via the Stack 223

Using Linux Kernel Services Through Syscall 231

Designing a Nontrivial Program 235

Going Further 248

Chapter 9 Bits, Flags, Branches, and Tables 251

Bits Is Bits (and Bytes Is Bits) 251

Shifting Bits 258

Bit-Bashing in Action 262

Flags, Tests, and Branches 270

X64 Long Mode Memory Addressing in Detail 279

Character Table Translation 290

Tables Instead of Calculations 298

Chapter 10 Dividing and Conquering 299

Boxes within Boxes 300

Calling and Returning 309

Local Labels and the Lengths of Jumps 325

Building External Procedure Libraries 330

The Art of Crafting Procedures 352

Simple Cursor Control in the Linux Console 356

Creating and Using Macros 364

Chapter 11 Strings and Things 377

The Notion of an Assembly Language String 378

REP STOSB, the Software Machine Gun 387

The Semiautomatic Weapon: STOSB Without REP 392

MOVSB: Fast Block Copies 397

Storing Data to Discontinuous Strings 402

Command-Line Arguments, String Searches, and the Linux Stack 408

The Stack, Its Structure, and How to Use It 414

Chapter 12 Heading Out to C 423

What's GNU? 424

Linking to the Standard C Library 429

Formatted Text Output with printf() 438

Data In with fgets() and scanf() 442

Be a Linux Time Lord 448

Understanding AT&T Instruction Mnemonics 456

Generating Random Numbers 460

How C Sees Command-Line Arguments 472

Simple File I/O 474

Conclusion: Not the End, But Only the Beginning 489

Appendix A The Return of the Insight Debugger 493

Insight's Shortcomings 494

Opening a Program Under Insight 495

Setting Command-Line Arguments with Insight 496

Running and Stepping a Program 496

The Memory Window 497

Showing the Stack in Insight's Memory View 498

Examining the Stack with Insight's Memory View 498

Learn gdb! 500

Appendix B Partial x64 Instruction Reference 501

What's Been Removed from x64 502

Flag Results 502

Size Specifiers 503

Instruction Index 505

ADC: Arithmetic Addition with Carry 507

ADD: Arithmetic Addition 509

AND: Logical AND 511

BT: Bit Test 513

CALL: Call Procedure 515

CLC: Clear Carry Flag (CF) 517

CLD: Clear Direction Flag (DF) 518

CMP: Arithmetic Comparison 519

DEC: Decrement Operand 521

DIV: Unsigned Integer Division 522

INC: Increment Operand 524

J??: Jump If Condition Is Met 525

JECXZ: Jump if ECX=0 527

JRCXZ: Jump If RCX=0 528

JMP: Unconditional Jump 529

LEA: Load Effective Address 531

LOOP: Loop Until CX/ECX/RCX=0 532

LOOPNZ/LOOPNE: Loop Until CX/ECX/RCX=0 and ZF=0 534

LOOPZ/LOOPE: Loop Until CX/ECX/RCX=0 and ZF=1 535

MOV: Copy Right Operand into Left Operand 536

MOVS: Move String 538

MOVSX: Copy with Sign Extension 540

MUL: Unsigned Integer Multiplication 542

NEG: Negate (Two's Complement; i.e., Multiply by .1) 544

NOP: No Operation 546

NOT: Logical NOT (One's Complement) 547

OR: Logical OR 548

POP: Copy Top of Stack into Operand 550

POPF/D/Q: Copy Top of Stack into Flags Register 552

PUSH: Push Operand onto Top of Stack 553

PUSHF/D/Q: Push Flags Onto the Stack 555

RET: Return from Procedure 556

ROL/ROR: Rotate Left/Rotate Right 558

SBB: Arithmetic Subtraction with Borrow 560

SHL/SHR: Shift Left/Shift Right 562

STC: Set Carry Flag (CF) 564

STD: Set Direction Flag (DF) 565

STOS/B/W/D/Q: Store String 566

SUB: Arithmetic Subtraction 568

SYSCALL: Fast System Call into Linux 570

XCHG: Exchange Operands 571

XLAT: Translate Byte Via Table 572

XOR: Exclusive OR 573

Appendix C Character Set Charts 575

Index 579
JEFF DUNTEMANN is an accomplished author of both science fiction and technical nonfiction. He has published dozens of technical articles in magazines, co-founded The Coriolis Group, a large publishing house in Arizona, and works as a technical publishing consultant. He owns Copperwood Press, a POD imprint hosted on