Muutke küpsiste eelistusi

E-raamat: Art of Assembly Language, 2nd Edition

3.82/5 (126 hinnangut Goodreads-ist)
  • Formaat: EPUB+DRM
  • Ilmumisaeg: 01-Mar-2010
  • Kirjastus: No Starch Press,US
  • Keel: eng
  • ISBN-13: 9781593273019
Teised raamatud teemal:
  • Formaat - EPUB+DRM
  • Hind: 43,04 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Art of Assembly Language, 2nd EditionSuurem pilt
  • Formaat: EPUB+DRM
  • Ilmumisaeg: 01-Mar-2010
  • Kirjastus: No Starch Press,US
  • Keel: eng
  • ISBN-13: 9781593273019
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Presents an introduction to High Level Assembler, covering such topics as editing, compiling, and running HLA programs; declaring and using constants; translating arithmetic expressions; and converting high-level control structures. This plain-English introduction to 32-bitx86 assembly language is for beginning programmers and non-assembly programmers with high-level language experience. The books primary teaching tool, High Level Assembler (HLA), incorporates many of the features found in high-level languages to help readers grasp basic assembly concepts, allowing beginning assembly programmers to work with familiar syntax. Coverage includes how to edit, compile, and run HLA programs, how to declare and use constants, scalar variables, and arrays, and how to translate arithmetic expressions. This second edition has been updated to reflect recent changes to HLA and to support Linux, Mac OS X, and FreeBSD. Hyde has taught at the University of California-Riverside. Annotation ©2010 Book News, Inc., Portland, OR (booknews.com) Assembly is a low-level programming language, one step above hardware’s native machine language. Assembly code is small, fast, and reliable. While assembly is not as popular as a daily programming language as high-level languages like C or Python, it is widely used for writing device drivers, embedded systems, viruses, and for programs that require real-time responses such as flight navigation systems. A working knowledge of assembly is key to successful reverse engineering and hacking of all kinds. The Art of Assembly Language is one of those classic texts that comes around only every once in a while. Widely respected by hackers of all kinds, it teaches programmers how to understand assembly language and how to use it to write powerful, efficient code. Using the proven High Level Assembler (HLA) as its primary teaching tool, The Art of Assembly Language leverages readers knowledge of high level programming languages to make it easier for readers to quickly grasp basic concepts. Among the most comprehensive references to assembly language every published, The Art of Assembly Language, 2nd Edition has been thoroughly updated to reflect recent changes to the HLA language. All code from the book is portable to the Windows, Linux, Mac OS X, and FreeBSD operating systems.

Arvustused

"The previous edition of Hyde's book has been my go-to book for assembly language for years, and there's little doubt this edition will be similarly long-lived." SD Times: Software Development News 

"Considering the fact that many people seem to have difficulties in learning assembler, this book is a very good read and effectively introduces the reader to this fascinating topic." The Ethical Hacker Network 

"The Art of Assembly Language is a welcome addition to the bookshelf of any programmer who has yet to experience and appreciate deeper understanding of HLA gained as a result of reading the book." Dr. Dobb's 

"The beauty of this book and HLA is that the HLA compiler insulates the beginner from the drudgery and trickery of getting started from zero knowledge." A.P. Lawrence

"And yes, people still do write in Assembly Language. And now, if you want to try this out for yourself, there is a great new book available to help you out. This is the second edition of Randall Hyde's The Art of Assembly Language." Scienceblogs.com

"I was reading The Art of Asssembly Language, 2nd Edition by Randall Hyde the other day and really enjoyed his approach to teaching the assembly language programming." Hex Blog 

"As I remarked in respect of the first edition, if you want to use assembly language, or add it to your list of programming skills, this is the book to have." Linux Users of Victoria 

"If you are a beginner and want to find your way into lower level programming and gain an understanding of how a machine's hardware works then this is a good way to get into things." I Programmer 

"By the end of the book, readers will be pretty comfortable writing in programs using HLA and will have a new understanding of how computers operate." YYZtech.ca 

"The Art of Assembly Language is a good book for teaching you the basics of Assembly through the use of HLA as Assembly 'training wheels.'" The Durham University Computing Society

Acknowledgments xix
Hello, World of Assembly Language
1(52)
The Anatomy of an HLA Program
2(2)
Running Your First HLA Program
4(1)
Some Basic HLA Data Declarations
5(2)
Boolean Values
7(1)
Character Values
8(1)
An Introduction to the Intel 80x86 CPU Family
8(3)
The Memory Subsystem
11(3)
Some Basic Machine Instructions
14(3)
Some Basic HLA Control Structures
17(15)
Boolean Expressions in HLA Statements
18(2)
The HLA if..then..elseif..else..endif Statement
20(2)
Conjunction, Disjunction, and Negation in Boolean Expressions
22(2)
The while..endwhile Statement
24(1)
The for..endfor Statement
25(1)
The repeat..until Statement
26(1)
The break and breakif Statements
27(1)
The forever..endfor Statement
28(1)
The try..exception..endtry Statement
28(4)
Introduction to the HLA Standard Library
32(10)
Predefined Constants in the stdio Module
33(1)
Standard In and Standard Out
34(1)
The stdout.newln Routine
35(1)
The stdout.puti X Routines
35(1)
The stdout.puti XSize Routines
35(2)
The stdout.put Routine
37(1)
The stdin.getc Routine
38(1)
The stdin.geti X Routines
39(1)
The stdin.readLn and stdin.flushinput Routines
40(1)
The stdin.get Routine
41(1)
Additional Details About try..endtry
42(8)
Nesting try..endtry Statements
43(2)
The unprotected Clause in a try..endtry Statement
45(3)
The anyexception Clause in a try..endtry Statement
48(1)
Registers and the try..endtry Statement
48(2)
High-Level Assembly Language vs. Low-Level Assembly Language
50(1)
For More Information
51(2)
Data Representation
53(58)
Numbering Systems
54(2)
A Review of the Decimal System
54(1)
The Binary Numbering System
54(1)
Binary Formats
55(1)
The Hexadecimal Numbering System
56(2)
Data Organization
58(6)
Bits
58(1)
Nibbles
59(1)
Bytes
60(1)
Words
61(1)
Double Words
62(1)
Quad Words and Long Words
63(1)
Arithmetic Operations on Binary and Hexadecimal Numbers
64(1)
A Note About Numbers vs. Representation
65(2)
Logical Operations on Bits
67(3)
Logical Operations on Binary Numbers and Bit Strings
70(2)
Signed and Unsigned Numbers
72(4)
Sign Extension, Zero Extension, Contraction, and Saturation
76(4)
Shifts and Rotates
80(5)
Bit Fields and Packed Data
85(4)
An Introduction to Floating-Point Arithmetic
89(11)
IEEE Floating-Point Formats
93(3)
HLA Support for Floating-Point Values
96(4)
Binary-Coded Decimal Representation
100(1)
Characters
101(8)
The ASCII Character Encoding
101(4)
HLA Support for ASCII Characters
105(4)
The Unicode Character Set
109(1)
For More Information
110(1)
Memory Access and Organization
111(44)
The 80x86 Addressing Modes
112(8)
80x86 32-Bit Memory Addressing Modes
113(6)
Runtime Memory Organization
119(1)
The code Section
120(7)
The static Section
122(1)
The readonly Data Section
123(1)
The storage Section
123(1)
The nostorage Attribute
124(1)
The var Section
125(1)
Organization of Declaration Sections Within Your Programs
126(1)
How HLA Allocates Memory for Variables
127(1)
HLA Support for Data Alignment
128(3)
Address Expressions
131(2)
Type Coercion
133(3)
Register Type Coercion
136(1)
The stack Segment and the push and pop Instructions
137(3)
The Basic push Instruction
137(1)
The Basic pop Instruction
138(2)
Preserving Registers with the push and pop Instructions
140(1)
The Stack Is a LIFO Data Structure
140(6)
Other push and pop Instructions
143
Removing Data from the Stack Without Popping It
140(6)
Accessing Data You've Pushed onto the Stack Without Popping It
146(1)
Dynamic Memory Allocation and the Heap Segment
147(5)
The inc and dec Instructions
152(1)
Obtaining the Address of a Memory Object
152(1)
For More Information
153(2)
Constants, Variables, and Data Types
155(100)
Some Additional Instructions: intmul, bound, into
156(4)
HLA Constant and Value Declarations
160(13)
Constant Types
164(1)
String and Character Literal Constants
165(2)
String and Text Constants in the const Section
167(2)
Constant Expressions
169(2)
Multiple const Sections and Their Order in an HLA Program
171(1)
The HLA val Section
172(1)
Modifying val Objects at Arbitrary Points in Your Programs
173(1)
The HLA Type Section
173(1)
enum and HLA Enumerated Data Types
174(1)
Pointer Data Types
175(10)
Using Pointers in Assembly Language
177(1)
Declaring Pointers in HLA
178(1)
Pointer Constants and Pointer Constant Expressions
179(1)
Pointer Variables and Dynamic Memory Allocation
180(1)
Common Pointer Problems
180(5)
Composite Data Types
185(1)
Character Strings
185(3)
HLA Strings
188(6)
Accessing the Characters Within a String
194(2)
The HLA String Module and Other String-Related Routines
196(12)
In-Memory Conversions
208(1)
Character Sets
209(1)
Character Set Implementation in HLA
210(2)
HLA Character Set Constants and Character Set Expressions
212(1)
Character Set Support in the HLA Standard Library
213(4)
Using Character Sets in Your HLA Programs
217(1)
Arrays
218(1)
Declaring Arrays in Your HLA Programs
219(1)
HLA Array Constants
220(1)
Accessing Elements of a Single-Dimensional Array
221(3)
Sorting an Array of Values
224(1)
Multidimensional Arrays
224(5)
Row-Major Ordering
225(3)
Column-Major Ordering
228(1)
Allocating Storage for Multidimensional Arrays
229(2)
Accessing Multidimensional Array Elements in Assembly Language
231(2)
Records
233(2)
Record Constants
235(1)
Arrays of Records
236(1)
Arrays/Records as Record Fields
237(4)
Aligning Fields Within a Record
241(1)
Pointers to Records
242(1)
Unions
243(3)
Anonymous Unions
246(1)
Variant Types
247(1)
Namespaces
248(3)
Dynamic Arrays in Assembly Language
251(3)
For More Information
254(1)
Procedures and Units
255(96)
Procedures
255(3)
Saving the State of the Machine
258(4)
Prematurely Returning from a Procedure
262(1)
Local Variables
262(6)
Other Local and Global Symbol Types
268(1)
Parameters
268(7)
Pass by Value
269(4)
Pass by Reference
273(2)
Functions and Function Results
275(7)
Returning Function Results
276(1)
Instruction Composition in HLA
277(3)
The HLA returns Option in Procedures
280(2)
Recursion
282(4)
Forward Procedures
286(1)
HLA v2.0 Procedures Declarations
287(1)
Low-Level Procedures and the call Instruction
288(2)
Procedures and the Stack
290(3)
Activation Records
293(3)
The Standard Entry Sequence
296(2)
The Standard Exit Sequence
298(1)
Low-Level Implementation of Automatic (Local) Variables
299(2)
Low-Level Parameter Implementation
301(28)
Passing Parameters in Registers
301(3)
Passing Parameters in the Code Stream
304(3)
Passing Parameters on the Stack
307(22)
Procedure Pointers
329(4)
Procedural Parameters
333(1)
Untyped Reference Parameters
334(1)
Managing Large Programs
335(1)
The #include Directive
336(1)
Ignoring Duplicate #include Operations
337(1)
Units and the external Directive
338(7)
Behavior of the external Directive
343(1)
Header Files in HLA
344(1)
Namespace Pollution
345(3)
For More Information
348(3)
Arithmetic
351(62)
80x86 Integer Arithmetic Instructions
351(14)
The mul and imul Instructions
352(3)
The div and idiv Instructions
355(2)
The cmp Instruction
357(5)
The setcc Instruction
362(2)
The test Instruction
364(1)
Arithmetic Expressions
365(10)
Simple Assignments
366(1)
Simple Expressions
366(3)
Complex Expressions
369(5)
Commutative Operators
374(1)
Logical (Boolean) Expressions
375(2)
Machine and Arithmetic Idioms
377(3)
Multiplying without mul, imul, or intmul
378(1)
Division Without div or idiv
379(1)
Implementing Modulo-N Counters with and
380(1)
Floating-Point Arithmetic
380(26)
FPU Registers
380(7)
FPU Data Types
387(2)
The FPU Instruction Set
389(1)
FPU Data Movement Instructions
389(2)
Conversions
391(3)
Arithmetic Instructions
394(5)
Comparison Instructions
399(3)
Constant Instructions
402(1)
Transcendental Instructions
402(2)
Miscellaneous Instructions
404(1)
Integer Operations
405(1)
Converting Floating-Point Expressions to Assembly Language
406(5)
Converting Arithmetic Expressions to Postfix Notation
407(2)
Converting Postfix Notation to Assembly Language
409(2)
HLA Standard Library Support for Floating-Point Arithmetic
411(1)
For More Information
411(2)
Low-Level Control Structures
413(64)
Low-Level Control Structures
414(1)
Statement Labels
414(2)
Unconditional Transfer of Control (imp)
416(2)
The Conditional Jump Instructions
418(3)
``Medium-Level'' Control Structures: it and if
421(1)
Implementing Common Control Structures in Assembly Language
422(1)
Introduction to Decisions
422(30)
if..then..else Sequences
424(3)
Translating HLA if Statements into Pure Assembly Language
427(5)
Implementing Complex if Statements Using Complete Boolean Evaluation
432(1)
Short-Circuit Boolean Evaluation
433(2)
Short-Circuit vs. Complete Boolean Evaluation
435(2)
Efficient Implementation of if Statements in Assembly Language
437(5)
switch/case Statements
442(10)
State Machines and Indirect Jumps
452(3)
Spaghetti Code
455(1)
Loops
456(10)
while Loops
457(1)
repeat..until Loops
458(1)
forever..endfor Loops
459(1)
for Loops
460(1)
The break and continue Statements
461(4)
Register Usage and Loops
465(1)
Performance Improvements
466(7)
Moving the Termination Condition to the End of a Loop
466(3)
Executing the Loop Backwards
469(1)
Loop-Invariant Computations
470(1)
Unraveling Loops
471(1)
Induction Variables
472(1)
Hybrid Control Structures in HLA
473(3)
For More Information
476(1)
Advanced Arithmetic
477(74)
Multiprecision Operations
478(52)
HLA Standard Library Support for Extended-Precision Operations
478(2)
Multiprecision Addition Operations
480(3)
Multiprecision Subtraction Operations
483(2)
Extended-Precision Comparisons
485(3)
Extended-Precision Multiplication
488(4)
Extended-Precision Division
492(9)
Extended-Precision neg Operations
501(2)
Extended-Precision and Operations
503(1)
Extended-Precision or Operations
503(1)
Extended-Precision xor Operations
504(1)
Extended-Precision not Operations
504(1)
Extended-Precision Shift Operations
504(4)
Extended-Precision Rotate Operations
508(1)
Extended-Precision I/O
509(21)
Operating on Different-Size Operands
530(2)
Decimal Arithmetic
532(7)
Literal BCD Constants
533(1)
The 80x86 daa and das Instructions
534(1)
The 80x86 aaa, aas, aam, and aad Instructions
535(2)
Packed Decimal Arithmetic Using the FPU
537(2)
Tables
539(10)
Function Computation via Table Lookup
539(5)
Domain Conditioning
544(1)
Generating Tables
545(3)
Table Lookup Performance
548(1)
For More Information
549(2)
Macros and The HLA Compile-Time Language
551(48)
Introduction to the Compile-Time Language (CTL)
551(2)
The #print and #error Statements
553(2)
Compile-Time Constants and Variables
555(1)
Compile-Time Expressions and Operators
555(3)
Compile-Time Functions
558(7)
Type-Conversion Compile-Time Functions
559(2)
Numeric Compile Time Functions
561(1)
Character-Classification Compile-Time Functions
561(1)
Compile-Time String Functions
561(1)
Compile-Time Symbol Information
562(1)
Miscellaneous Compile-Time Functions
563(1)
Compile-Time Type Conversions of Text Objects
564(1)
Conditional Compilation (Compile-Time Decisions)
565(5)
Repetitive Compilation (Compile-Time Loops)
570(3)
Macros (Compile-Time Procedures)
573(19)
Standard Macros
574(2)
Macro Parameters
576(6)
Local Symbols in a Macro
582(3)
Macros as Compile-Time Procedures
585(1)
Simulating Function Overloading with Macros
586(6)
Writing Compile-Time ``Programs''
592(6)
Constructing Data Tables at Compile Time
592(4)
Unrolling Loops
596(2)
Using Macros in Different Source Files
598(1)
For More Information
598(1)
Bit Manipulation
599(34)
What Is Bit Data, Anyway?
600(1)
Instructions That Manipulate Bits
601(8)
The Carry Flag as a Bit Accumulator
609(1)
Packing and Unpacking Bit Strings
609(3)
Coalescing Bit Sets and Distributing Bit Strings
612(3)
Packed Arrays of Bit Strings
615(2)
Searching for a Bit
617(3)
Counting Bits
620(3)
Reversing a Bit String
623(2)
Merging Bit Strings
625(1)
Extracting Bit Strings
626(1)
Searching for a Bit Pattern
627(1)
The HLA Standard Library Bits Module
628(3)
For More Information
631(2)
The String Instructions
633(18)
The 80x86 String Instructions
634(16)
How the String Instructions Operate
634(1)
The rep/repe/repz and repnz/repne Prefixes
635(1)
The Direction Flag
636(2)
The movs Instruction
638(9)
The cmps Instruction
647(1)
The scas Instruction
647(1)
The Stos Instruction
648(1)
The lods Instruction
648(1)
Building Complex String Functions from lods and stos
649(1)
Performance of the 80x86 String Instructions
650(1)
For More Information
650(1)
Classes and Objects
651(50)
General Principles
652(2)
Classes in HLA
654(3)
Objects
657(2)
Inheritance
659(1)
Overriding
660(1)
Virtual Methods vs. Static Procedures
661(2)
Writing Class Methods and Procedures
663(5)
Object Implementation
668(9)
Virtual Method Tables
671(2)
Object Representation with Inheritance
673(4)
Constructors and Object Initialization
677(9)
Dynamic Object Allocation Within the Constructor
679(2)
Constructors and Inheritance
681(4)
Constructor Parameters and Procedure Overloading
685(1)
Destructors
686(1)
HLA's_initialize_and_finalize_Strings
687(6)
Abstract Methods
693(3)
Runtime Type Information
696(2)
Calling Base Class Methods
698(1)
For More Information
699(2)
Appendix ASCII Character Set 701(4)
Index 705
Randall Hyde is the author of Write Great Code Volumes 1 and 2 (No Starch Press) and the co-author of MASM 6.0 Bible (The Waite Group). He has written for Dr. Dobb's Journal, Byte, and various professional journals. Hyde taught assembly language at the University of California, Riverside for over a decade.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97815932730196e.html
Märksõnad: