Muutke küpsiste eelistusi

E-raamat: Introduction to Assembly Language Programming: For Pentium and RISC Processors

3.40/5 (10 hinnangut Goodreads-ist)
  • Formaat: PDF+DRM
  • Sari: Texts in Computer Science
  • Ilmumisaeg: 28-Sep-2005
  • Kirjastus: Springer-Verlag New York Inc.
  • Keel: eng
  • ISBN-13: 9780387271552
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 98,18 €*
  • * 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.
Introduction to Assembly Language Programming: For Pentium and RISC ProcessorsSuurem pilt
  • Formaat: PDF+DRM
  • Sari: Texts in Computer Science
  • Ilmumisaeg: 28-Sep-2005
  • Kirjastus: Springer-Verlag New York Inc.
  • Keel: eng
  • ISBN-13: 9780387271552
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. 

Assembly language continues to hold a core position in the programming world because of its similar structure to machine language and its very close links to underlying computer-processor architecture and design. These features allow for high processing speed, low memory demands, and the capacity to act directly on the system's hardware. This completely revised second edition of the highly successful Introduction to Assembly Language Programming introduces the reader to assembly language programming and its role in computer programming and design. The focus is on providing readers with a firm grasp of the main features of assembly programming, and how it can be used to improve a computer's performance. The revised edition covers a broad scope of subjects and adds valuable material on protected-mode Pentium programming, MIPS assembly language programming, and use of the NASM and SPIM assemblers for a Linux orientation. All of the language's main features are covered in depth. The book requires only some basic experience with a structured, high-level language.



Topics and Features: Introduces assembly language so that readers can benefit from learning its utility with both CISC and RISC processors [ NEW ].- Employs the freely available NASM assembler, which works with both Microsoft Windows and Linux operating systems [ NEW ].- Contains a revised chapter on "Basic Computer Organization" [ NEW].- Uses numerous examples, hands-on exercises, programming code analyses and challenges, and chapter summaries.- Incorporates full new chapters on recursion, protected-mode interrupt processing, and floating-point instructions [ NEW ].



Assembly language programming is part of several undergraduate curricula in computer science, computer engineering, and electrical engineering. In addition, this newly revised text/reference can be used as an ideal companion resource in a computer organization course or as a resource for professional courses.
Preface vii
PART I: Overview
1(45)
Introduction
3(16)
A User's View of Computer Systems
4(1)
What Is Assembly Language?
5(3)
Advantages of High-Level Languages
8(1)
Why Program in the Assembly Language?
9(1)
Typical Applications
10(1)
Why Learn the Assembly Language?
11(1)
Performance: C Versus Assembly Language
12(2)
Multiplication Algorithm
12(2)
Summary
14(1)
Exercises
14(1)
Programming Exercises
15(1)
Program Listings
15(4)
Basic Computer Organization
19(27)
Basic Components of a Computer System
20(2)
The Processor
22(2)
The Execution Cycle
22(1)
The System Clock
23(1)
Number of Addresses
24(4)
Three-Address Machines
24(1)
Two-Address Machines
25(1)
One-Address Machines
26(1)
Zero-Address Machines
26(1)
The Load/Store Architecture
26(1)
Processor Registers
27(1)
Flow of Control
28(4)
Branching
28(2)
Procedure Calls
30(2)
Memory
32(6)
Two Basic Memory Operations
33(2)
Types of Memory
35(2)
Storing Multibyte Data
37(1)
Input/Output
38(3)
Performance: Effect of Data Alignment
41(2)
Summary
43(1)
Exercises
43(3)
PART II: Pentium Assembly Language
46(299)
The Pentium Processor
47(20)
The Pentium Processor Family
47(2)
The Pentium Registers
49(4)
Data Registers
50(1)
Pointer and Index Registers
50(1)
Control Registers
51(2)
Segment Registers
53(1)
Protected-Mode Memory Architecture
53(6)
Segment Registers
54(1)
Segment Descriptors
55(2)
Segment Descriptor Tables
57(1)
Segmentation Models
58(1)
Real-Mode Memory Architecture
59(3)
Mixed-Mode Operation
62(1)
Which Segment Register to Use
63(1)
Initial State
64(1)
Summary
65(1)
Exercises
65(2)
Overview of Assembly Language
67(50)
Assembly Language Statements
68(1)
Data Allocation
69(5)
Where Are the Operands?
74(4)
Register Addressing Mode
75(1)
Immediate Addressing Mode
75(1)
Direct Addressing Mode
76(1)
Indirect Addressing Mode
77(1)
Data Transfer Instructions
78(2)
The MOV Instruction
78(1)
Ambiguous Moves
79(1)
The XCHG Instruction
79(1)
The XLAT Instruction
80(1)
Overview of Assembly Language Instructions
80(13)
Simple Arithmetic Instructions
80(3)
Conditional Execution
83(3)
Iteration Instruction
86(1)
Logical Instructions
87(2)
Shift Instructions
89(2)
Rotate Instructions
91(2)
Defining Constants
93(2)
The EQU Directive
93(1)
The % assign Directive
94(1)
The %define Directive
94(1)
Macros
95(3)
Illustrative Examples
98(10)
Performance: When to Use XLAT Instruction
108(2)
Experiment 1
108(2)
Experiment 2
110(1)
Summary
110(1)
Exercises
111(2)
Programming Exercises
113(4)
Procedures and the Stack
117(50)
What Is a Stack?
118(1)
Pentium Implementation of the Stack
118(2)
Stack Operations
120(3)
Basic Instructions
120(1)
Additional Instructions
121(2)
Uses of the Stack
123(1)
Temporary Storage of Data
123(1)
Transfer of Control
124(1)
Parameter Passing
124(1)
Procedures
124(2)
Pentium Instructions for Procedures
126(2)
How Is Program Control Transferred?
127(1)
The ret Instruction
128(1)
Parameter Passing
128(18)
Register Method
129(3)
Stack Method
132(3)
Preserving Calling Procedure State
135(1)
Which Registers Should Be Saved
136(1)
ENTER and LEAVE Instructions
137(1)
Illustrative Examples
138(8)
Handling a Variable Number of Parameters
146(4)
Local Variables
150(6)
Multiple Source Program Modules
156(3)
Performance: Procedure Overheads
159(1)
Procedure Overheads
159(1)
Local Variable Overhead
160(1)
Summary
160(2)
Exercises
162(1)
Programming Exercises
163(4)
Addressing Modes
167(30)
Introduction
167(2)
Memory Addressing Modes
169(4)
Based Addressing
171(1)
Indexed Addressing
171(2)
Based-Indexed Addressing
173(1)
Illustrative Examples
173(7)
Arrays
180(6)
One-dimensional Arrays
180(1)
Multidimensional Arrays
181(3)
Examples of Arrays
184(2)
Performance: Usefulness of Addressing Modes
186(4)
Summary
190(1)
Exercises
191(1)
Programming Exercises
192(5)
Arithmetic Flags and Instructions
197(42)
Status Flags
197(14)
The Zero Flag
198(2)
The Carry Flag
200(3)
The Overflow Flag
203(2)
The Sign Flag
205(1)
The Auxiliary Flag
206(2)
The Parity Flag
208(1)
Flag Examples
209(2)
Arithmetic Instructions
211(7)
Multiplication Instructions
211(4)
Division Instructions
215(3)
Illustrative Examples
218(6)
PutInt8 Procedure
218(3)
GetInt8 Procedure
221(3)
Multiword Arithmetic
224(8)
Addition and Subtraction
224(1)
Multiplication
225(4)
Division
229(3)
Performance: Multiword Multiplication
232(1)
Summary
233(1)
Exercises
234(1)
Programming Exercises
235(4)
Selection and Iteration
239(32)
Unconditional Jump
239(3)
Compare Instruction
242(2)
Conditional Jumps
244(6)
Jumps Based on Single Flags
244(2)
Jumps Based on Unsigned Comparisons
246(1)
Jumps Based on Signed Comparisons
247(2)
A Note on Conditional Jumps
249(1)
Looping Instructions
250(2)
Implementing High-Level Language Decision Structures
252(5)
Selective Structures
252(3)
Iterative Structures
255(2)
Illustrative Examples
257(6)
Indirect Jumps
263(3)
Multiway Conditional Statements
266(1)
Summary
266(2)
Exercises
268(1)
Programming Exercises
269(2)
Logical and Bit Operations
271(30)
Logical Instructions
272(6)
The and Instruction
272(3)
The or Instruction
275(1)
The xor Instruction
276(2)
The not Instruction
278(1)
The test Instruction
278(1)
Shift Instructions
278(6)
Logical Shift Instructions
279(2)
Arithmetic Shift Instructions
281(1)
Why Use Shifts for Multiplication and Division?
282(1)
Doubleshift Instructions
283(1)
Rotate Instructions
284(2)
Rotate Without Carry
284(1)
Rotate Through Carry
285(1)
Logical Expressions in High-Level Languages
286(4)
Representation of Boolean Data
286(1)
Logical Expressions
286(1)
Bit Manipulation
287(1)
Evaluation of Logical Expressions
288(2)
Bit Instructions
290(1)
Bit Test and Modify Instructions
291(1)
Bit Scan Instructions
291(1)
Illustrative Examples
291(6)
Summary
297(1)
Exercises
297(2)
Programming Exercises
299(2)
String Processing
301(28)
String Representation
301(2)
Explicitly Storing String Length
302(1)
Using a Sentinel Character
303(1)
String Instructions
303(9)
Repetition Prefixes
304(1)
Direction Flag
305(1)
String Move Instructions
306(3)
String Compare Instruction
309(2)
Scanning a String
311(1)
Illustrative Examples
312(9)
Testing String Procedures
321(2)
Performance: Advantage of String Instructions
323(1)
Summary
324(1)
Exercises
325(1)
Programming Exercises
326(3)
ASCII and BCD Arithmetic
329(16)
ASCII and BCD Representations of Numbers
330(1)
ASCII Representation
330(1)
BCD Representation
330(1)
Processing in ASCII Representation
331(5)
ASCII Addition
332(1)
ASCII Subtraction
333(1)
ASCII Multiplication
334(1)
ASCII Division
334(1)
Example: Multidigit ASCII Addition
335(1)
Processing Packed BCD Numbers
336(4)
Packed BCD Addition
336(2)
Packed BCD Subtraction
338(1)
Example: Multibyte Packed BCD Addition
338(2)
Performance: Decimal Versus Binary Arithmetic
340(1)
Summary
341(1)
Exercises
342(2)
Programming Exercises
344(1)
PART III: MIPS Assembly Language
345(54)
MIPS Processor
347(14)
Introduction
347(2)
Evolution of CISC Processors
349(2)
RISC Design Principles
351(3)
MIPS Architecture
354(4)
Summary
358(1)
Exercises
359(2)
MIPS Assembly Language
361(38)
MIPS Instruction Set
361(12)
Instruction Format
362(1)
Data Transfer Instructions
363(1)
Arithmetic Instructions
364(4)
Logical Instructions
368(1)
Shift Instructions
369(1)
Rotate Instructions
370(1)
Comparison Instructions
371(1)
Branch and Jump Instructions
371(2)
SPIM Simulator
373(5)
SPIM System Calls
373(2)
SPIM Assembler Directives
375(2)
MIPS Program Template
377(1)
Illustrative Examples
378(8)
Procedures
386(5)
Stack Implementation
391(2)
Summary
393(1)
Exercises
394(1)
Programming Exercises
395(4)
PART IV: Pentium Interrupt Processing
399(62)
Protected-Mode Interrupt Processing
401(22)
Introduction
401(1)
A Taxonomy of Interrupts
402(1)
Interrupt Processing in the Protected Mode
403(4)
Exceptions
407(2)
Software Interrupts
409(1)
File I/O
410(4)
File Descriptor
410(1)
File Pointer
410(1)
File System Calls
410(4)
Illustrative Examples
414(4)
Hardware Interrupts
418(1)
Summary
419(1)
Exercises
420(1)
Programming Exercises
420(3)
Real-Mode Interrupts
423(38)
Interrupt Processing in the Real Mode
424(1)
Software Interrupts
425(1)
Keyboard Services
426(14)
Keyboard Description
426(1)
DOS Keyboard Services
427(4)
Extended Keyboard Keys
431(3)
BIOS Keyboard Services
434(6)
Text Output to Display Screen
440(1)
Exceptions: An Example
441(3)
Direct Control of I/O Devices
444(2)
Accessing I/O Ports
444(2)
Peripheral Support Chips
446(3)
8259 Programmable Interrupt Controller
446(2)
8255 Programmable Peripheral Interface Chip
448(1)
I/O Data Transfer
449(8)
Programmed I/O
450(2)
Interrupt-driven I/O
452(5)
Summary
457(1)
Exercises
458(1)
Programming Exercises
458(3)
PART V: Advanced Topics
461(66)
Recursion
463(20)
Introduction
463(1)
Recursion in Pentium Assembly Language
464(7)
Recursion in MIPS Assembly Language
471(7)
Recursion Versus Iteration
478(1)
Summary
479(1)
Exercises
479(1)
Programming Exercises
479(4)
High-Level Language Interface
483(24)
Why Program in Mixed Mode?
484(1)
Overview
484(2)
Calling Assembly Procedures from C
486(7)
Illustrative Examples
488(5)
Calling C Functions from Assembly
493(2)
Inline Assembly
495(9)
The AT&T Syntax
496(1)
Simple Inline Statements
497(1)
Extended Inline Statements
498(2)
Inline Examples
500(4)
Summary
504(1)
Exercises
504(1)
Programming Exercises
504(3)
Floating-Point Operations
507(20)
Introduction
507(1)
Floating-Point Unit Organization
508(4)
Data Registers
508(2)
Control and Status Registers
510(2)
Floating-Point Instructions
512(7)
Data Movement
513(1)
Addition
514(1)
Subtraction
514(1)
Multiplication
515(1)
Division
516(1)
Comparison
517(1)
Miscellaneous
518(1)
Illustrative Examples
519(5)
Summary
524(1)
Exercises
524(1)
Programming Exercises
525(2)
Appendices
527(150)
A Internal Data Representation
529(38)
A.1 Positional Number Systems
529(2)
A.1.1 Notation
531(1)
A.2 Number Systems Conversion
532(1)
A.2.1 Conversion to Decimal
532(2)
A.2.2 Conversion from Decimal
534(2)
A.2.3 Conversion Among Binary, Octal, and Hexadecimal
536(2)
A.3 Unsigned Integer Representation
538(1)
A.3.1 Arithmetic on Unsigned Integers
539(6)
A.4 Signed Integer Representation
545(1)
A.4.1 Signed Magnitude Representation
546(1)
A.4.2 Excess-M Representation
547(1)
A.4.3 1's Complement Representation
547(3)
A.4.4 2's Complement Representation
550(1)
A.5 Floating-Point Representation
551(1)
A.5.1 Fractions
552(3)
A.5.2 Representing Floating-Point Numbers
555(1)
A.5.3 Floating-Point Representation
556(4)
A.5.4 Floating-Point Addition
560(1)
A.5.5 Floating-Point Multiplication
561(1)
A.6 Character Representation
561(2)
A.7 Summary
563(1)
A.8 Exercises
564(2)
A.9 Programming Exercises
566(1)
B Assembling and Linking
567(16)
B.1 Introduction
567(1)
B.2 Structure of Assembly Language Programs
568(1)
B.3 Input/Output Routines
569(5)
B.4 Assembling and Linking
574(1)
B.4.1 The Assembly Process
574(7)
B.4.2 Linking Object Files
581(1)
B.5 Summary
581(1)
B.6 Web Resources
581(1)
B.7 Exercises
581(1)
B.8 Programming Exercises
582(1)
C Debugging Assembly Language Programs
583(22)
C.1 Strategies to Debug Assembly Language Programs
583(3)
C.2 Preparing Your Program
586(1)
C.3 GNU Debugger
586(1)
C.3.1 Display Group
587(5)
C.3.2 Execution Group
592(3)
C.3.3 Miscellaneous Group
595(1)
C.3.4 An Example
595(2)
C.4 Data Display Debugger
597(5)
C.5 Summary
602(1)
C.6 Web Resources
603(1)
C.7 Exercises
603(1)
C.8 Programming Exercises
603(2)
D SPIM Simulator and Debugger
605(10)
D.1 Introduction
605(3)
D.2 Simulator Settings
608(2)
D.3 Running and Debugging a Program
610(1)
D.3.1 Loading and Running
610(1)
D.3.2 Debugging
610(3)
D.4 Summary
613(1)
D.5 Exercises
613(1)
D.6 Programming Exercises
613(2)
E IA-32 Instruction Set
615(36)
E.1 Instruction Format
615(1)
E.1.1 Instruction Prefixes
615(2)
E.1.2 General Instruction Format
617(1)
E.2 Selected Instructions
618(33)
F MIPS/SPIM Instruction Set
651(22)
G ASCII Character Set
673(4)
Index 677
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97803872715522e.html
Märksõnad: