Hohl / Hinds ARM Assembly Language

Fundamentals and Techniques, Second Edition
2. Auflage 2014
ISBN: 978-1-4822-2986-8
Verlag: Taylor & Francis
Format: PDF
Kopierschutz: Adobe DRM (»Systemvoraussetzungen)

E-Book, Englisch, 453 Seiten

Delivering a solid introduction to assembly language and embedded systems, ARM Assembly Language: Fundamentals and Techniques, Second Edition continues to support the popular ARM7TDMI, but also addresses the latest architectures from ARM, including Cortex™-A, Cortex-R, and Cortex-M processors—all of which have slightly different instruction sets, programmer’s models, and exception handling.

Featuring three brand-new chapters, a new appendix, and expanded coverage of the ARM7™, this edition:

- Discusses IEEE 754 floating-point arithmetic and explains how to program with the IEEE standard notation

- Contains step-by-step directions for the use of Keil™ MDK-ARM and Texas Instruments (TI) Code Composer Studio™

- Provides a resource to be used alongside a variety of hardware evaluation modules, such as TI’s Tiva Launchpad, STMicroelectronics’ iNemo and Discovery, and NXP Semiconductors’ Xplorer boards

Written by experienced ARM processor designers, ARM Assembly Language: Fundamentals and Techniques, Second Edition covers the topics essential to writing meaningful assembly programs, making it an ideal textbook and professional reference.

Zielgruppe

Second- and third-year undergraduate students and computer science, computer engineering, and electrical engineering professionals.

Autoren/Hrsg.

Hohl, William

Hinds, Christopher

Fachgebiete

• Mathematik | Informatik EDV | Informatik EDV & Informatik Allgemein

Inhaltsverzeichnis

Preface

Authors

An Overview of Computing Systems

Introduction

History of RISC

ARM Begins

The Creation of ARM Ltd

ARM Today

The Cortex Family

The Computing Device

Number Systems

Representations of Numbers and Characters

Integer Representations

Floating-Point Representations

Character Representations

Translating Bits to Commands

The Tools

Open Source Tools

Keil (ARM)

Code Composer Studio

Useful Documentation

Exercises

The Programmer’s Model

Introduction

Data Types

ARM7TDMI

Processor Modes

Registers

The Vector Table

Cortex-M4

Processor Modes

Registers

The Vector Table

Exercises

Introduction to Instruction Sets: v4T and v7-M

Introduction

ARM, Thumb, and Thumb-2 Instructions

Program 1: Shifting Data

Running the Code

Examining Register and Memory Contents

Program 2: Factorial Calculation

Program 3: Swapping Register Contents

Program 4: Playing with Floating-Point Numbers

Program 5: Moving Values between Integer and Floating-Point Registers

Programming Guidelines

Exercises

Assembler Rules and Directives

Introduction

Structure of Assembly Language Modules

Predefined Register Names

Frequently Used Directives

Defining a Block of Data or Code

Register Name Definition

Equating a Symbol to a Numeric Constant

Declaring an Entry Point

Allocating Memory and Specifying Contents

Aligning Data or Code to Appropriate Boundaries

Reserving a Block of Memory

Assigning Literal Pool Origins

Ending a Source File

Macros

Miscellaneous Assembler Features

Assembler Operators

Math Functions in CCS

Exercises

Loads, Stores, and Addressing

Introduction

Memory

Loads and Stores: The Instructions

Operand Addressing

Pre-Indexed Addressing

Post-Indexed Addressing

Endianness

Changing Endianness

Defining Memory Areas

Bit-Banded Memory

Memory Considerations

Exercises

Constants and Literal Pools

Introduction

The ARM Rotation Scheme

Loading Constants into Registers

Loading Constants with MOVW, MOVT

Loading Addresses into Registers

Exercises

Integer Logic and Arithmetic

Introduction

Flags and Their Use

The N Flag

The V Flag

The Z Flag

The C Flag

Comparison Instructions

Data Processing Operations

Boolean Operations

Shifts and Rotates

Addition/Subtraction

Saturated Math Operations

Multiplication

Multiplication by a Constant

Division

DSP Extensions

Bit Manipulation Instructions

Fractional Notation

Exercises

Branches and Loops

Introduction

Branching

Branching (ARM7TDMI)

Version 7-M Branches

Looping

While Loops

For Loops

Do-While Loops

Conditional Execution

v4T Conditional Execution

v7-M Conditional Execution: The IT Block

Straight-Line Coding

Exercises

Introduction to Floating-Point: Basics, Data Types, and Data Transfer

Introduction

A Brief History of Floating-Point in Computing

The Contribution of Floating-Point to the Embedded Processor

Floating-Point Data Types

The Space of Floating-Point Representable Values

Floating-Point Representable Values

Normal Values

Subnormal Values

Zeros

Infinities

Not-a-Numbers (NaNs)

The Floating-Point Register File of the Cortex-M4

FPU Control Registers

The Floating-Point Status and Control Register, FPSCR

The Coprocessor Access Control Register, CPACR

Loading Data into Floating-Point Registers

Floating-Point Loads and Stores: The Instructions

The VMOV instruction

Conversions between Half-Precision and Single-Precision

Conversions to Non-Floating-Point Formats

Conversions between Integer and Floating-Point

Conversions between Fixed-Point and Floating-Point

Exercises

Introduction to Floating-Point: Rounding and Exceptions

Introduction

Rounding

Introduction to Rounding Modes in the IEEE 754-2008 Specification

The roundTiesToEven (RNE) Rounding Mode

The Directed Rounding Modes

Rounding Mode Summary

Exceptions

Introduction to Floating-Point Exceptions

Exception Handling

Division by Zero

Invalid Operation

Overflow

Underflow

Inexact Result

Algebraic Laws and Floating-Point

Normalization and Cancelation

Exercises

Floating-Point Data-Processing Instructions

Introduction

Floating-Point Data-Processing Instruction Syntax

Instruction Summary

Flags and Their Use

Comparison Instructions

The N Flag

The Z Flag

The C Flag

The V Flag

Predicated Instructions, or the Use of the Flags

A Word about the IT Instruction

Two Special Modes

Flush-to-Zero Mode

Default NaN

Non-Arithmetic Instructions

Absolute Value

Negate

Arithmetic Instructions

Addition/Subtraction

Multiplication and Multiply–Accumulate

Division and Square Root

Putting It All Together: A Coding Example

Exercises

Tables

Introduction

Integer Lookup Tables

Floating-Point Lookup Tables

Binary Searches

Exercises

Subroutines and Stacks

Introduction

The Stack

LDM/STM Instructions

PUSH and POP

Full/Empty Ascending/Descending Stacks

Subroutines

Passing Parameters to Subroutines

Passing Parameters in Registers

Passing Parameters by Reference

Passing Parameters on the Stack

The ARM APCS

Exercises

Exception Handling: ARM7TDMI

Introduction

Interrupts

Error Conditions

Processor Exception Sequence

The Vector Table

Exception Handlers

Exception Priorities

Procedures for Handling Exceptions

Reset Exceptions

Undefined Instructions

Interrupts

Aborts

SVCs

Exercises

Exception Handling: v7-M

Introduction

Operation Modes and Privilege Levels

The Vector Table

Stack Pointers

Processor Exception Sequence

Entry

Exit

Exception Types

Interrupts

Exercises

Memory-Mapped Peripherals

Introduction

The LPC2104

The UART

The Memory Map

Configuring the UART

Writing the Data to the UART

Putting the Code Together

Running the Code

The LPC2132

The D/A Converter

The Memory Map

Configuring the D/A Converter

Generating a Sine Wave

Putting the Code Together

Running the Code

The Tiva Launchpad

General-Purpose I/O

The Memory Map

Configuring the GPIO Pins

Turning on the LEDs

Putting the Code Together

Running the Code

Exercises

ARM, Thumb and Thumb-2 Instructions

Introduction

ARM and 16-Bit Thumb Instructions

Differences between ARM and 16-Bit Thumb

Thumb Implementation

32-Bit Thumb Instructions

Switching between ARM and Thumb States

How to Compile for Thumb

Exercises

Mixing C and Assembly

Introduction

Inline Assembler

Inline Assembly Syntax

Restrictions on Inline Assembly Operations

Embedded Assembler

Embedded Assembly Syntax

Restrictions on Embedded Assembly Operations

Calling between C and Assembly

Exercises

Appendix A: Running Code Composer Studio

Appendix B: Running Keil Tools

Appendix C: ASCII Character Codes

Appendix D

Glossary

References

Index

Über Autor(innen)

William Hohl held the position of worldwide university relations manager for ARM, based in Austin, Texas, for 10 years. In total, he was with ARM for nearly 15 years and began as a principal design engineer to help build the ARM1020 microprocessor. His travel and university lectures have taken him to over 40 countries on 5 continents, and he continues to lecture on low-power microcontrollers and assembly language programming. In addition to his engineering duties, he also held an adjunct faculty position in Austin from 1998 to 2004, teaching undergraduate mathematics. Before joining ARM, he worked at Motorola (now Freescale Semiconductor) in the ColdFire and 68040 design groups and at Texas Instruments as an applications engineer. He holds MSEE and BSEE degrees from Texas A&M University as well as six patents in the field of debug architectures.

Christopher Hinds has worked in the microprocessor design field for over 25 years, holding design positions at Motorola (now Freescale Semiconductor), AMD, and ARM. While at ARM, he was the primary author of the ARM VFP floating-point architecture and led the design of the ARM10 VFP, the first hardware implementation of the new architecture. He recently joined the Patents Group in ARM, identifying patentable inventions within the company and assisting in patent litigation. He holds BSEE and MSEE degrees from Texas A&M University and an M.Div from Oral Roberts University, where he worked to establish the School of Engineering, creating and teaching the first digital logic and microprocessor courses. He has numerous published papers and presentations on the floating-point architecture of ARM processors, and is a named inventor on over 30 US patents in the areas of floating-point implementation, instruction set design, and circuit design.