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.

  Autorentext

  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 amazon.com.

  Klappentext

  An engaging and essential update of the bestselling introduction to Intel assembly language Assembly language is where the program code meets the silicon. Nevertheless, most beginners and many software engineers struggle with assembly, instead relying on high-level languages to do the job. In this fourth edition of x64 Assembly Language Step-by-Step: Programming with Linux, celebrated author Jeff Duntemann delivers a completely rewritten introduction to assembly language focused on 64-bit long-mode under Linux. The author covers computing and programming basics, binary and hexadecimal number bases, the x64 architecture, and the process of Linux software development. Along the way you'll get hands-on experience with the x64 instruction set, memory addressing, procedures, macros, and interfacing to the C library functions upon which Linux is built. The book is lighthearted, robust, and accessible, offering a step-by-step path to assembly coding that covers the bases while being easy to read. You'll learn the free NASM assembler and debugging tools you can download and use immediately, along with numerous code examples throughout the book. You'll also get practical tips on software design, coding, testing, and debugging that will sharpen your assembly programming skills. x64 Assembly Language Step-by-Step: Programming with Linux, 4th Edition, is an authoritative tutorial to Intel/AMD x64 technology that's perfect for self-paced instruction. This latest edition will cement the book's reputation as the gold standard for x64 assembly language introductions.

  Inhalt

  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 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/…