Assembler for ARM processors

Original title: ARM Assembly Language: Fundamentals and Techniques
Translation: Paweł Gonera
ISBN: 978-83-246-9319-1
Release date: 2014-10-10
Format: 168x237
Pages: 352

About the book

Programmer's guide!

Until recently, not many people were aware of the existence of solutions such as ARM processors. This state of affairs has changed the invasion of mobile devices: tablets, smartphones and platforms such as Raspberry Pi. A new challenge emerged from professional programmers - getting to know the assembler of the ARM platform.

If you belong to this group, you've come across a great book devoted to this topic. During the reading you will become acquainted with the ways of representing numbers and characters and the ARM7TDMI programming model. Then you will create your first program using assembler and you will learn the language's directive. Further chapters are further elements of programming in assembler language. Addressing, loading data, logical and arithmetic operations, loops and conditional instructions are just some of the issues addressed. With this book you will also gain valuable knowledge about peripheral devices and handling exceptions. The book is an excellent read for all programmers creating software for ARM processors.

Thanks to this book:

• you will learn the assembly language for ARM architecture
• you will master the directives and rules for using the assembler
• you will perform typical logic and arithmetic operations
• You can easily use typical language constructions

Discover the secrets of the assembly language for ARM processors!

Table of Contents

Introduction (11) Acknowledgments (15) Information about the software (17) Author (19) Chapter 1. Overview of computer systems (21)

• 1.1. Introduction (21)
• 1.2. History of RISC architecture (23)
  • 1.2.1. The origins of ARM (25)
  • 1.2.2. Establishment of ARM Ltd. (26)
  • 1.2.3. ARM currently (28)
• 1.3. Calculating devices (29)
• 1.4. Numerical systems (31)
• 1.5. Number and character representation (34)
  • 1.5.1. Representation of whole numbers (34)
  • 1.5.2. Floating point representation (37)
  • 1.5.3. Character representation (39)
• 1.6. Translation of bits on orders (39)
• 1.7. Tools (41)
• 1.8. Exercises (43)

Chapter 2. ARM7TDMI programming model (47)

• 2.1. Introduction (47)
• 2.2. Data types (47)
• 2.3. Processor modes (48)
• 2.4. Registers (49)
• 2.5. Registers of program status (51)
  • 2.5.1. Control bits (51)
  • 2.5.2. Mode bits (51)
• 2.6. Table of Vectors (52)
• 2.7. Exercises (53)

Chapter 3. The first programs (55)

• 3.1. Introduction (55)
• 3.2. Program 1: Moving data (56)
  • 3.2.1. Running the code (57)
  • 3.2.2. Checking the contents of registers and memories (58)
• 3.3. Program 2: Calculation of power (58)
• 3.4. Program 3: Exchange of register contents (61)
• 3.5. Programming Tips (61)
• 3.6. Exercises (63)

Chapter 4. Directives and rules for using assembler (65)

• 4.1. Introduction (65)
• 4.2. The structure of assembler language modules (65)
• 4.3. Predefined register names (68)
• 4.4. Commonly used directives (68)
  • 4.4.1. AREA - definition of a block of data or code (69)
  • 4.4.2. RN - definition of the registry name (70)
  • 4.4.3. EQU - symbol definition for a numerical constant (70)
  • 4.4.4. ENTRY - entry point declaration (71)
  • 4.4.5. DCB, DCW and DCD - memory allocation and content determination (71)
  • 4.4.6. ALIGN - aligning data or code to the appropriate limit (72)
  • 4.4.7. SPACE - memory block reservation (73)
  • 4.4.8. LTORG - assigning a starting point for a literal pool (73)
  • 4.4.9. END - end of the source file (74)
• 4.5. Macros (74)
• 4.6. Other assembler functions (76)
  • 4.6.1. Assembler operations (76)
  • 4.6.2. Literals (77)
• 4.7. Exercises (77)

Chapter 5. Loading, saving and addressing (79)

• 5.1. Introduction (79)
• 5.2. Memory (79)
• 5.3. Loading and saving instructions (82)
• 5.4. Addressing operations (85)
  • 5.4.1. Pre-indexed addressing (85)
  • 5.4.2. Post-indexed addressing (86)
• 5.5. The order of bytes (88)
  • 5.5.1. Changing the order of bytes (89)
  • 5.5.2. Defining memory areas (90)
• 5.6. Exercises (91)

Chapter 6. Constants and literal literal pools (95)

• 6.1. Introduction (95)
• 6.2. ARM rotation scheme (95)
• 6.3. Loading constants into registers (98)
• 6.4. Loading addresses into registers (101)
• 6.5. Exercises (105)

Chapter 7. Logic and arithmetic operations (107)

• 7.1. Introduction (107)
• 7.2. Tags and their use (107)
  • 7.2.1. Marker N (108)
  • 7.2.2. Marker V (108)
  • 7.2.3. Marker Z (109)
  • 7.2.4. Marker C (109)
• 7.3. Compare instructions (109)
• 7.4. Data processing operations (110)
  • 7.4.1. Logic operations (111)
  • 7.4.2. Transfers and rotations (112)
  • 7.4.3. Addition and subtraction (117)
  • 7.4.4. Multiplication (119)
  • 7.4.5. Multiplication by constant (120)
  • 7.4.6. Sharing (121)
• 7.5. Fractional notation (122)
• 7.6. Exercises (127)

Chapter 8. Loops and jumps (131)

• 8.1. Introduction (131)
• 8.2. Jumps (132)
• 8.3. Loops (135)
  • 8.3.1. While loops (135)
  • 8.3.2. For loops (136)
  • 8.3.3. Loops for ... while (139)
• 8.4. More about tags (139)
• 8.5. Conditional execution (140)
• 8.6. Coding in a straight line (142)
• 8.7. Exercises (143)

Chapter 9. Boards (145)

• 9.1. Introduction (145)
• 9.2. Search boards (145)
• 9.3. Jump tables (149)
• 9.4. Binary search (150)
• 9.5. Exercises (153)

Chapter 10. Subroutines and Stacks (157)

• 10.1. Introduction (157)
• 10.2. Stack (158)
  • 10.2.1. LDM and STM instructions (158)
  • 10.2.2. Stacks full, empty, rising and falling (160)
• 10.3. Subprograms (162)
• 10.4. Passing parameters to subroutines (163)
  • 10.4.1. Parameter transfer through registers (163)
  • 10.4.2. Passing parameters by reference (165)
  • 10.4.3. Passing parameters on the stack (167)
• 10.5. Standard ARM APCS (168)
• 10.6. Exercises (169)

Chapter 11. Exception handling (173)

• 11.1. Introduction (173)
• 11.2. Interrupts (173)
• 11.3. Errors (174)
• 11.4. Exception sequence in the processor (175)
• 11.5. Vector table (176)
• 11.6. Handlers of exceptions (179)
• 11.7. Exception priorities (180)
• 11.8. Exception handlers (181)
  • 11.8.1. Reset exception (181)
  • 11.8.2. Undefined statement (181)
  • 11.8.3. Interrupts (185)
  • 11.8.4. Interrupt errors (194)
  • 11.8.5. SWI (195)
• 11.9. Exercises (196)

Chapter 12. Peripherals with mapped memory (199)

• 12.1. Introduction (199)
• 12.2. LPC2104 (200)
  • 12.2.1. UART system (200)
  • 12.2.2. Memory map (200)
  • 12.2.3. Configuring the UART (202)
  • 12.2.4. Writing data to UART (205)
  • 12.2.5. Complete code (206)
  • 12.2.6. Running the application (207)
• 12.3. The LPC2132 system (208)
  • 12.3.1. Konwerter C / A (208)
  • 12.3.2. Memory map (210)
  • 12.3.3. Configuration of the D / A converter (210)
  • 12.3.4. Generation of a sine wave (210)
  • 12.3.5. Complete code (212)
  • 12.3.6. Running the code (214)
• 12.4. Exercises (214)

Chapter 13. THUMB (217)

• 13.1. Introduction (217)
• 13.2. THUMB instructions (218)
• 13.3. Differences between ARM and THUMB (220)
• 13.4. Implementation and use of THUMB (221)
  • 13.4.1. Processor modifications (221)
  • 13.4.2. Switching between the ARM and THUMB state (221)
• 13.5. Compilation for THUMB (223)
• 13.6. Exercises (225)

Chapter 14. Combining C and Assembler (227)

• 14.1. Introduction (227)
• 14.2. Assembler Inserts (227)
  • 14.2.1. Syntax of assembler elements (230)
  • 14.2.2. Limitations of assembly assemblies (231)
• 14.3. Assembler built-in (232)
  • 14.3.1. Assembled assembler syntax (234)
  • 14.3.2. Limitations of the built-in assembly language (234)
• 14.4. Calls between C and assembler (234)
• 14.5. Exercises (236)

Appendix A. ARM V4T instruction set (239) Appendix B. Using Keil tools (339)

• B.1. Introduction (339)
• B.2. Project creation and device selection (339)
• B.3. Creating application code (341)
• B.4. Building a project and running the code (343)

Appendix C. ASCII Character Codes (345) Glossary (347) References (349) Index (350)