You are previewing Itanium® Architecture for Programmers: Understanding 64-Bit Processors and EPIC Principles.
O'Reilly logo
Itanium® Architecture for Programmers: Understanding 64-Bit Processors and EPIC Principles

Book Description

  • Step-by-step guide to assembly language for the 64-bit Itanium processors, with extensive examples

  • Details of Explicitly Parallel Instruction Computing (EPIC): Instruction set, addressing, register stack engine, predication, I/O, procedure calls, floating-point operations, and more

  • Learn how to comprehend and optimize open source, Intel, and HP-UX compiler output

Understand the full power of 64-bit Itanium EPIC processors

Itanium® Architecture for Programmers is a comprehensive introduction to the breakthrough capabilities of the new 64-bit Itanium architecture. Using standard command-line tools and extensive examples, the authors illuminate the Itanium design within the broader context of contemporary computer architecture via a step-by-step investigation of Itanium assembly language. Coverage includes:

  • The potential of Explicitly Parallel Instruction Computing (EPIC)

  • Itanium instruction formats and addressing modes

  • Innovations such as the register stack engine (RSE) and extensive predication

  • Procedure calls and procedure-calling mechanisms

  • Floating-point operations

  • I/O techniques, from simple debugging to the use of files

  • Optimization of output from open source, Intel, and HP-UX compilers

An essential resource for both computing professionals and students of architecture or assembly language, Itanium Architecture for Programmers includes extensive printed and Web-based references, plus many numeric, essay, and programming exercises for each chapter.

Table of Contents

  1. Copyright
  2. Hewlett-Packard® Professional Books
  3. List of Figures
  4. List of Tables
  5. Preface
  6. Trademarks
  7. Architecture and Implementation
    1. Analogy: Piano Architecture
    2. Types of Computer Languages
    3. Why Study Assembly Language?
    4. Prefixes for Binary Multiples
    5. Instruction Set Architectures
    6. The Life Cycle of Computer Architectures
    7. SQUARES: A First Programming Example
    8. Review of Number Systems
    9. Summary
    10. References
    11. Exercises
  8. Computer Structures and Data Representations
    1. Computer Structures
    2. Instruction Execution
    3. Classes of Instruction Set Architectures
    4. Migration to 64-Bit Architectures
    5. Itanium Information Units and Data Types
    6. Summary
    7. References
    8. Exercises
  9. The Program Assembler and Debugger
    1. Programming Environments
    2. Program Development Steps
    3. Comparing Variants of a Source File
    4. Assembler Statement Types
    5. The Functions of a Symbolic Assembler
    6. The Assembly Process
    7. The Linking Process
    8. The Program Debugger
    9. Conventions for Writing Programs
    10. Summary
    11. References
    12. Exercises
  10. Itanium Instruction Formats and Addressing
    1. Overview of Itanium Instruction Formats
    2. Integer Arithmetic Instructions
    3. Bit Encoding for Itanium Instructions
    4. HEXNUM: Using Arithmetic Instructions
    5. Data Access Instructions
    6. Other ALU Instructions
    7. DOTPROD: Using Data Access Instructions
    8. Itanium Addressing Modes
    9. Addressing in Other Architectures
    10. Summary
    11. References
    12. Exercises
  11. Comparison, Branches, and Predication
    1. Hardware Basis for Control of Flow
    2. Integer Compare Instructions
    3. Program Branching
    4. DOTLOOP: Using a Counted Loop
    5. Stops, Instruction Groups, and Performance
    6. DOTCLOOP: Using the Loop Count Register
    7. Other Structured Programming Constructs
    8. MAXIMUM: Using Conditional Instructions
    9. Summary
    10. References
    11. Exercises
  12. Logical Operations, Bit-Shifts, and Bytes
    1. Logical Functions
    2. HEXNUM2: Using Logical Masks
    3. Bit and Field Operations
    4. SCANTEXT: Processing Bytes
    5. Integer Multiplication and Division
    6. DECNUM: Converting an Integer to Decimal Format
    7. Using C for ASCII Input and Output
    8. BACKWARD: Using Byte Manipulations
    9. Summary
    10. References
    11. Exercises
  13. Subroutines, Procedures, and Functions
    1. Memory Stacks
    2. DECNUM2: Using Stack Operations
    3. Register Stacks
    4. Program Segmentation
    5. Calling Conventions
    6. DECNUM3 and BOOTH: Making a Function
    7. Integer Quotients and Remainders
    8. RANDOM: A Callable Function
    9. Summary
    10. References
    11. Exercises
  14. Floating-Point Operations
    1. Parallels Between Integer and Floating-Point Instructions
    2. Representations of Floating-Point Values
    3. Copying Floating-Point Data
    4. Floating-Point Arithmetic Instructions
    5. HORNER: Evaluating a Polynomial
    6. Predication Based on Floating-Point Values
    7. Integer Operations in Floating-Point Execution Units
    8. Approximations for Reciprocals and Square Roots
    9. APPROXPI: Using Floating-Point Instructions
    10. Summary
    11. References
    12. Exercises
  15. Input and Output of Text
    1. File Systems
    2. Keyboard and Display I/O
    3. SCANTERM: Using C Standard I/O
    4. SORTSTR: Sorting Strings
    5. Text File I/O
    6. SCANFILE: Input and Output with Files
    7. SORTINT: Sorting Integers from a File
    8. Binary Files
    9. Summary
    10. References
    11. Exercises
  16. Performance Considerations
    1. Processor-Level Parallelism
    2. Instruction-Level Parallelism
    3. Explicit Parallelism in the Itanium Processors
    4. Software-Pipelined Loops
    5. Modulo Scheduling a Loop
    6. Program Optimization Factors
    7. Fibonacci Numbers
    8. Summary
    9. References
    10. Exercises
  17. Looking at Output from Compilers
    1. Compilers for RISC-like Systems
    2. Compiling a Simple Program
    3. Optimizing a Simple Program
    4. Inline Optimizations
    5. Profile-Guided or Other Optimizations
    6. Debugging Optimized Programs
    7. Recursion for Fibonacci Numbers Revisited
    8. Summary
    9. References
    10. Exercises
  18. Parallel Operations
    1. Classification of Computing Systems
    2. Integer Parallel Operations
    3. Applications to Integer Multiplication
    4. Opportunities and Challenges
    5. Floating-Point Parallel Operations
    6. Semaphore Support for Parallel Processes
    7. Summary
    8. References
    9. Exercises
  19. Variations Among Implementations
    1. Why Implementations Change
    2. How Implementations Change
    3. The Original Itanium Processor
    4. A Major Role for Software
    5. IA -32 Instruction Set Mode
    6. Determining Extensions and Implementation Version
    7. Summary
    8. References
    9. Exercises
  20. Command-Line Environments
    1. Logging in
    2. Logging out
    3. Security
    4. Text editing
    5. Uploading files
    6. Learning about commands
    7. Learning about your environment
    8. Inspecting an HP-UX or Linux file
    9. References
    10. Exercises
  21. Suggested System Resources
    1. System Hardware
    2. System Software
    3. Desktop Client Access Software
    4. References
  22. Itanium Instruction Set
    1. References
  23. Itanium Registers and Their Uses
    1. Instruction Pointer
    2. General Registers and NaT Bits
    3. Predicate Registers
    4. Branch Registers
    5. Floating-Point Registers
    6. Application Registers
    7. State Management Registers
    8. System Information Registers
    9. System Control Registers
    10. References
  24. Conditional Assembly and Macros (GCC Assembler)
    1. Interference from Explicit Stops
    2. Repeat Blocks
    3. Conditional Assembly
    4. Macro Processing
    5. Using Labels with Macros
    6. Recursive Macros
    7. Object File Sections
    8. MONEY: A Macro Illustrating Sections
    9. Summary
    10. References
    11. Exercises
  25. Inline Assembly
    1. HP-UX C Compilers
    2. GCC Compiler for Linux
    3. Intel Compilers for Linux
    4. References
  26. Bibliography
  27. Answers and Hints for Selected Exercises
    1. Chapter 1
    2. Chapter 2
    3. Chapter 3
    4. Chapter 4
    5. Chapter 5
    6. Chapter 6
    7. Chapter 7
    8. Chapter 8
    9. Chapter 9
    10. Chapter 10
    11. Chapter 11
    12. Chapter 12
    13. Chapter 13
    14. Appendix E
  28. About the Authors