Table of Contents for
Modern Assembly Language Programming with the ARM Processor

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Modern Assembly Language Programming with the ARM Processor by Larry D. Pyeatt Published by Newnes, 2016
  1. Modern Assembly Language Programming with the ARM Processor
  2. Cover image
  3. Title page
  4. Table of Contents
  5. Copyright
  6. List of Tables
  7. List of Figures
  8. List of Listings
  9. Preface
  10. Companion Website
  11. Acknowledgments
  12. Part I: Assembly as a Language
  13. Chapter 1: Introduction
  14. Chapter 2: GNU Assembly Syntax
  15. Chapter 3: Load/Store and Branch Instructions
  16. Chapter 4: Data Processing and Other Instructions
  17. Chapter 5: Structured Programming
  18. Chapter 6: Abstract Data Types
  19. Part II: Performance Mathematics
  20. Chapter 7: Integer Mathematics
  21. Chapter 8: Non-Integral Mathematics
  22. Chapter 9: The ARM Vector Floating Point Coprocessor
  23. Chapter 10: The ARM NEON Extensions
  24. 10.10 Multiplication and Division
  25. Part III: Accessing Devices
  26. Chapter 11: Devices
  27. Chapter 12: Pulse Modulation
  28. Chapter 13: Common System Devices
  29. Chapter 14: Running Without an Operating System
  30. Index

Index

Note: Page numbers followed by b indicate boxes, f indicate figures and t indicate tables.

A

Absolute difference 339–340
Absolute value 340–341
Abstract data type (ADT) 
in assembly language 138–139
big integer ADT 195–196, 211
in C header file 138
implementation of 137
interface 137
Therac-25 
design flaws 163–165
history of 162–163
X-ray therapy 161
use of 137
word frequency counts 
better performance 150–161
C header for 141–142
C implementation 141–142, 145
C program to compute 140–141
makefile for 141–142, 146
revised makefile for 148–150
sorting by 147–150
wl_print_numerical function 147–150, 157–161
Accessing devices, Linux 365–376
Acorn Archimedes™ 8
Acorn RISC Machine (ARM) processor 8–9
Addition 
in decimal and binary 173b
fixed-point operation 231–232
floating point operation 246–247
subtraction by 172
vector 335–337
VFP 278
ADT.  See Abstract data type (ADT)
American Standard Code for Information Interchange (ASCII) 
control characters 20, 21t
converting character strings to ASCII codes 21–23, 23t, 24t
interpreting data as ASCII strings 23–24, 24t
ISO extensions to ASCII 24–25, 25t
unicode and UTF-8 25–28, 27t
Arbitrary base 
base ten to 11
to decimal, conversion 220–223
Arithmetic and logic unit (ALU) 54–55
Arithmetic instructions, ARM 83–85
Arithmetic instructions, NEON 335–343
absolute difference 339–340
absolute value and negate 340–341
add vector elements pairwise 338–339
count bits 342–343
select maximum/minimum elements 341–342
vector addition and subtraction 335–337
ARM assembly 
automatic variables 118–119
calling scanf and printf 110–111
complex selection 103–104
function call using stack 115–116
for loop re-written as a post-test loop 107–108
post-test loop 106, 108
pre-test loop 105–107
program 36
reverse function implementation 121–122
simple function call 114
structured data type 124–126
unconditional loop 104–105
ARM condition modifiers 59t
ARM CPU modes 432–435
ARM instruction set architecture 95–96
data processing instructions 79–80
arithmetic operations 83–85
comparison operations 81–82
data movement operations 86–87
division operations 89–90
logical operations 85–86
multiply operations with 32-bit results 87–88
multiply operations with 64-bit results 88–89
Operand2 80, 80t, 81t
pseudo-instructions, ARM 93
no operation 93–94
shifts 94–95
special instructions 
accessing CPSR and SPSR 91
count leading zeros 90
software interrupt 91–92
thumb mode 92–93
ARM processor 
architecture 54f
ARM user registers 55–58, 56f, 57f
branch instructions 70
branch 70–71
branch and link 71–72
load/store instructions 60–61
addressing modes 61–63, 61t
exclusive load/store 69–70
multiple register 65–68
single register 64
swap 68–69
profiles 461–464
pseudo-instructions 73
load address 75–76
load immediate 73–75
ARM user program registers 112f
Assembler 38–40
Assembly language 3
ADTs 138–139
reason to learn 4–8
Atomic Energy of Canada Limited (AECL) 161–162

B

Bare-metal programs 
coding on 431
compiling 449
exception processing 435–436
features 432
linker script 447–448
main program 445–447
Raspberry Pi 442
startup code 443–445
writing 442–449
Base address 
clock manager device 407
for GPIO device 378–379
in memory 367
PWM device 398
Big integer ADT 195–216
bigint_adc function 213–216
C source code file 211
factorial function calculation 212
header file 196
Binary division 
constant 190–194
flowchart for 183f
large numbers 194–195
power of two 181
64-bit functions, signed and unsigned 190
32-bit functions, signed and unsigned 190
variable 182–186
Binary multiplication 
algorithm for 175
large numbers 179–181, 180f
power of two 173
signed multiplication 178–179, 179f, 180b
64 bit numbers 175–176
32-bit numbers 176–177
of two variables 173–176
variable by constant 177–178
Binary tree, of word frequency 151f
index added 157f
sorted index 158f
Binimals 223–224
non-terminating, repeating 223b
terminating 224
Bitwise logical operations, NEON 326–327
with immediate data 327–328, 352–353
insertion and selection 328–329
Boot loader 442, 447
Boot process 442
Branch instructions, ARM processor 70
branch 70–71
branch and link 71–72

C

Central processing unit (CPU) 
components and data paths 54–55
description 3–4
C language 
array of integers 124
array of structured data 127
calling scanf and printf 110
complex selection 103
larger function call 114
for loop 106
program 36
using recursion to reverse a string 120–121
Clock Control Unit (CCU) 409
Clock management device 405–409, 406f
control registers 408t
divisor registers 408t
pcDuino CCU 409
Raspberry Pi 406–409
registers 407t
Communications 
parallel 409
serial 409–429
pcDuino UART 422–429
Raspberry Pi UART0 413–422
UART 410–412
Compare instruction 
ARM 81–82
vector 323–324
vector absolute 353–354
VFP 279
Compilation sequence 5, 6f
Compiler, GNU C 38–40
Complex Instruction Set Computing (CISC) processor 8
Computer data 9
base conversion 
base b to decimal 11–12, 12b
base conversion 10t, 11–15
bases, powers-of-two 14–15, 14f
conversion between arbitrary bases 13b
decimal to base b 12, 13b
characters 20–28, 21t, 22t
non-printing 20–21
printing 20, 22t
ISO 24–25
Unicode and UTF-8 25–28
integers 15, 16f
complement representation 16–19, 17f, 18b, 19b
excess-(2n−−1–1) representation 16
sign-magnitude representation 15
natural numbers 9–11
Conditional assembly 46–47
Control registers 
clock management device 407, 408t
pcDuino UART FIFO 425t
Raspberry Pi UART 416, 417t
Cosine function 
ARM assembly implementation 251, 257
battery powered systems 260
double precision software float C 259
double precision VFP C 260
factorial terms, formats and constants for 249–251
formats for powers of x 248–249
intermediate calculations 251
performance comparison 259–260
performance implementations 259t
properties 247–248
single precision software float C 259
single precision VFP C 259
table printing 251, 258
32-bit fixed point assembly 259
32-bit fixed point C 259
Count bits 342–343
CPU.  See Central processing unit (CPU)
Current Program Status Register (CPSR) 57–58
accessing 91
flag bits 58, 58t

D

Data conversion instructions 
NEON 321–322
fixed point and single-precision 321–322
half-precision and single-precision 322
vector floating point 
fixed point to single precision 284–285
floating point to integer 282–284
Data frame 410
Data movement instructions 
ARM 86–87
NEON 309–320
change size of elements in vector 311–312
duplicate scalar 312–313
extract elements 313–314
move immediate data 310–311
moving between NEON scalar and integer register 309–310
reverse elements 314–315
swap vectors 315–316
table lookup 317–319
transpose matrix 316–317
zip/unzip vectors 319–320
vector floating point 279–282
ARM register and VFP system register 282
between two VFP registers 279–280
VFP register and one integer register 280–281
VFP register and two integer registers 281
Data processing instructions, ARM 79–80
arithmetic operations 83–85
comparison operations 81–82
data movement operations 86–87
division operations 89–90
logical operations 85–86
multiply operations 
with 64-bit results 88–89
with 32-bit results 87–88
Operand2 80, 80t, 81t
vector floating point 277–279
compare instruction 279
mathematical operations 278
unary operations 277–278
Data register, Raspberry Pi UART 413, 414t
Data section, memory 28–29
Decimal 223–224
to arbitrary base, conversion 220–223
terminating 224
Direct Memory Access (DMA) 377–378
control register 418
Division 
binary 
constant 190–194
flowchart for 183f
large numbers 194–195
power of two 181
64-bit functions, signed and unsigned 190
32-bit functions, signed and unsigned 190
variable 182–186
by constant 236–241
in decimal and binary 181f
fixed-point operation 234–236
floating point operation 247
maintaining precision 236
mixed 235
NEON 343
results of 234–235
signed 235
unsigned 235
of variable by constant 193
VFP 278
Divisor registers 
clock management device 408t
divisor latch high register 424, 425t
divisor latch low register 424, 424t
DMA.  See Direct Memory Access (DMA)
Double-precision floating point number 
IEEE 754 245–246
sine function 355, 357
Duty cycle 395

E

Exception handling 438–441, 461
skeleton for 441
stub functions 438–441
Exception processing 434–441, 436f
ARM vector table 434–435, 435t
bare-metal programs 435–436
handling exceptions 438–441
skeleton for 441
stub functions 438–441
with multiple user processes 436, 437f
Executing program, memory layout of 28–31, 29f, 30f
Extract elements 313–314

F

Fault Tree Analysis 162
FIFO control register 425t
Fixed-point numbers 
interpreting 226–230
properties of 230–231
Q notation 230
signed 227–228
two’s complement 229
unsigned 226, 228
Fixed-point operation 
addition 231–232
division 
by constant 236–241
maintaining precision 236
mixed 235
results of 234–235
signed 235
unsigned 235
multiplication 232–233
to single-precision 284–285, 321–322
subtraction 231–232
Flags register 414, 415t
Floating-point Exception register (FPEXC) 274
Floating point numbers 
binimal representation 242–243
IEEE 754 
double-precision 245–246
half-precision 243–245
quad-precision 246
single-precision 245
to integer 282–284
Floating point operations 
addition 246–247
division 247
multiplication 247
subtraction 246–247
Floating Point Status and Control Register (FPSCR) 268–273
bits in 268–269, 268f
performance vs. compliance 271–272
vector mode 272–273
Floating-point System ID register (FPSID) 274
Fractional baud rate divisor 414, 416t
Fractional numbers, base conversion 223–225
arbitrary base to decimal 220
decimal to arbitrary base 220–223
powers-of-two 222–223
Full-compliance mode 272
Fused multiply accumulate operation 346

G

GAS.  See GNU assembler (GAS)
General Purpose I/O (GPIO) device 376–392, 395
applications 377–378
features 377–378
GPIO pin event detect status registers 382
GPIO pin pull-up/down registers 381–382
input and output 378f
LED 377–378
parallel printer port 377
pcDuino 382–392
detecting GPIO events 390
enabling internal pull-up/pull-down 389–390
function select code assignments 392t
GPIO pins available on 390–392
header pin assignments 391f
reading and setting GPIO pins 388–389
setting GPIO pin function 384–385
pin function select bits 380t
port 376–377
Raspberry Pi 378–382
detecting GPIO events 382
enabling internal pull-up/pull-down 381–382
GPIO pins available on 382
header pin assignments 384f
reading GPIO input pins 381
setting GPIO output pins 380–381
setting GPIO pin function 379–380
Generic Interrupt Controller (GIC) device 449–451
GNU assembler (GAS) 35, 40
directives 40
allocating space for variables and constants 41–43, 42f
conditional assembly 46–47
current section selection 40–41
filling and aligning 43–45
including other source files 47–48
macros 48–50
setting and manipulating symbols 45–47
program structure 36, 38
assembler directives 36–38
assembly instructions 36, 38
comments 37
labels 37
GNU C compiler 38–40, 57
GPIO device.  See General Purpose I/O (GPIO) device

H

Half-precision floating point number 
IEEE 754 243–245
to single-precision 322
Hardware interrupt 434
High-level language 
description 4–5
structured data type 73–74
Hindu-Arabic number system 9–10

I

IBM PC 377
Image data type 138–139
Immediate data 
bitwise logical operations with 327–328, 352–353
data movement NEON instructions 310–311
Information hiding 137
Instruction components 58
immediate values 59–60, 60t
setting and using condition flags 58–59, 58t
Instruction set architecture (ISA) 53
Instruction stream 3
Integer baud rate divisor 414, 416t
Integer mathematics 
big integer ADT 195–216
binary division 
constant 190–194
large numbers 194–195
power of two 181
variable 182–186
binary multiplication by 
large numbers 179–181
power of two 173
signed multiplication 178–179, 180b
two variables 173–176
variable by constant 177–178
division 236, 239
floating point to 282–284
overflow 171
subtraction by addition 172
Integer register 
moving between NEON scalar and 309–310
VFP register and 280–281
Interrupt clear register 418
Interrupt controllers 449–451
Interrupt-driven program 461
Interrupt enable register 429
Interrupt Identity Register 429
Interrupt mask set/clear register 417
ISA.  See Instruction set architecture (ISA)

L

Least significant bit (LSB) 11
LED, GPIO device 377–378
Line control register 
pcDuino UART 425, 426t
Raspberry Pi UART 416, 416t
Line driver 410
Line status register 426, 427t
Linked list 
index creation 147, 157f
re-ordering 147
sorted index 158f
sorting 147
Linker 38–40, 46
Linker script 447–448
Linux, accessing devices under 365–376
Load and store instructions 60–61
ARM 55–58
addressing modes 61–63, 61t
exclusive load/store 69–70
multiple register 65–68
NEON 302–309
load copies of structure to all lanes 305–307
multiple structures data 307–309
single structure using one lane 303–305, 304t
single register 64
swap 68–69
VFP 274–277
Load constant 351–352
Loop unrolling 355
Low pass filter 395–396, 398

M

Macros, GNU assembly directives 48–50
Masked interrupt status register 418
Mathematical operations, VFP 278
Memory 
base address in 367
of executing program 28–31, 29f, 30f
hardware address mapping for 366f
on Raspberry Pi 372
Modem Control Register 429
Modem Scratch Register 429
Modem Status Register 429
Monostable multivibrator 400
Most significant bit (MSB) 11
Multiplication 
binary 
algorithm for 175
large numbers 179–181, 180f
power of two 173
signed multiplication 178–179, 179f, 180b
64 bit numbers 175–176
32-bit numbers 176–177
of two variables 173–176
variable by constant 177–178
in decimal and binary 174b
fixed-point operation 232–233
floating point operation 247
mixed 233
NEON 343–351
estimate reciprocals 348–349
fused multiply accumulate 346
reciprocal step 349–351
saturating multiply and double 347–348
by scalar 345–346
signed 233
unsigned 233
VFP 278
Multistage noise shaping (MASH) filtering 407

N

NEON instructions 298–299, 358–361
arithmetic instructions 335–343
absolute difference 339–340
absolute value and negate 340–341
add vector elements pairwise 338–339
count bits 342–343
select maximum/minimum elements 341–342
vector addition and subtraction 335–337
bitwise logical operations 326–327
with immediate data 327–328
insertion and selection 328–329
comparison operations 322–326
vector absolute compare 324–325
vector comparison 323–324
vector test bits 325–326
data conversion between 
fixed point and single-precision 321–322
half-precision and single-precision 322
data movement instructions 309–320
change size of elements in vector 311–312
duplicate scalar 312–313
extract elements 313–314
move immediate data 310–311
moving between NEON scalar and integer register 309–310
reverse elements 314–315
swap vectors 315–316
table lookup 317–319
transpose matrix 316–317
zip/unzip vectors 319–320
intrinsics functions 299
load and store instructions 302–309
load copies of structure to all lanes 305–307, 308t
multiple structures 306t, 307–309
single structure using one lane 303–305, 304t
multiplication and division 343–351
estimate reciprocals 348–349
fused multiply accumulate 346
reciprocal step 349–351
saturating multiply and double 347–348
by scalar 345–346
pseudo-instructions 351–354
bitwise logical operations with immediate data 352–353
load constant 351–352
vector absolute compare 353–354
shift instructions 329–334
saturating shift right by immediate 332–333
shift and insert 333–334
shift left by immediate 329–330
shift left/right by variable 330–331
shift right by immediate 331–332
sine function 354–358, 357t
double precision 355, 357
performance comparison 357–358, 357t
single precision 354–355
syntax of 299–302
user program registers 300f
Newlib 432
Newton-Raphson method 343, 348–349
for improving reciprocal estimates 349–350
Non-integral mathematics 
fixed-point numbers 
interpreting 226–230
properties of 230–231
Q notation 230
fixed-point operations 
addition and subtraction 231–232
division 234–241
multiplication 232–233
floating point numbers 
double-precision, IEEE 754 245–246
half-precision, IEEE 754 243–245
quad-precision, IEEE 754 246
single-precision, IEEE 754 245
floating point operations 
addition and subtraction 246–247
multiplication and division 247
fractional numbers, base conversion 
arbitrary base to decimal 220
decimal to arbitrary base 220–223
fractions and bases 223–225
Patriot missile failure 261–263
sine and cosine function 
factorial terms, formats and constants 249–251
formats for powers of x 248–249
performance comparison 259–260
table printing 258
using fixed-point calculations 257

O

Operand2 80, 80t, 81t
Operating system 431–432
designers 365–366

P

Parallel communications 409
Patriot missile failure 261–263
pcDuino 382–392
bare-metal programs 
linker script 447
main program 445–447
startup code 445
boot process 442
Clock Control Unit 409
GPIO 
detecting events 390
enabling internal pull-up/pull-down 389–390
function select code assignments 392t
header locations 390f
header pin assignments 391f
pin function setting 384–385
pins available on 390–392
reading and setting GPIO pins 388–389
user program memory space on 372, 376
interrupt controllers 449–451, 457
PWM device 400–403
configuring 403
control register bits 402t
prescaler bits 401t
register map 401t
timer0 device 458, 460
UART 422–429
addresses 422t
divisor latch high register 424, 425t
divisor latch low register 424, 424t
FIFO control register 425t
interrupt control 429
interrupt enable register 429
Interrupt Identity Register 429
line control register 425, 426t
line status register 426, 427t
Modem Control Register 429
Modem Scratch Register 429
Modem Status Register 429
receive buffer register 423, 424t
receive FIFO level register 426, 428t
register offsets 423t
status register 426, 427t
transmit FIFO level register 426, 428t
transmit halt register 428, 428t
transmit holding register 424, 424t
PDM.  See Pulse density modulation (PDM)
PDP-11 163
Privileged mode 432–433
Program Status Register (PSR) 433–434
mode bits 434t
Pseudo-instructions, ARM processor 73, 93
load address 75–76
load immediate 73–75
NEON 351–354
bitwise logical operations with immediate data 352–353
load constant 351–352
vector absolute compare 353–354
no operation 93–94
shifts 94–95
Pulse density modulation (PDM) 396, 396f
Pulse frequency modulation (PFM) 396, 396f
Pulse modulation 
pcDuino PWM device 400–403
PDM 396, 396f
PWM 397, 397f
Raspberry Pi PWM device 398–400, 400b
types 395
Pulse width modulation (PWM) 397, 397f
pcDuino PWM device 400–403
Raspberry Pi PWM device 398–400, 400b

Q

Q notation 230
Quad-precision floating point number 246

R

Radix point 220
Radix ten Hindu-Arabic system 10
Raspberry Pi 365–367
bare-metal programs 442
linker script 447
main program 445–447
startup code 445
clock management device 406–409
GPIO 378–382
detecting events 382
enabling internal pull-up/pull-down 381–382
header pin assignments 384f
output pins setting 380–381
pin alternate functions 385t
pin function setting 379–380
pins available on 382
reading input pins 381
register 379t
user program memory on 372
header location 383f
interrupt controllers 441, 451
PWM device 398–400, 400b
clock values on 400
control register bits 399t
register map 398t
timer0 device 458–461
UART 413–418
assembly functions for 422
basic programming for 418–422
control register 416, 417t
data register 413, 414t
DMA control register 418
flags register bits 414, 415t
fractional baud rate divisor 414, 416t
integer baud rate divisor 414, 416t
interrupt clear register 418
interrupt control 417
interrupt mask set/clear register 417
line control register bits 416, 416t
masked interrupt status register 418
raw interrupt status register 418
receive status register/error clear register 414, 415t
registers 413t
Raw interrupt status register 418
Receive buffer register, UART 423, 424t
Receive FIFO level register, UART 426, 428t
Receive status register/error clear register 414, 415t
Reciprocals 
estimate 348–349
step 349–351
Reduced Instruction Set Computing (RISC) processor 8
Reverse elements 314–315
RS-232 standard 410, 412
RS-422 standards 410, 412
RS-485 standards 410, 412
RunFast mode 272

S

Saved Process Status Register (SPSR) 432–433
Scalar 
duplication 312–313
multiplication by 345–346
sine function using 285–286
Serial communications 409–429
pcDuino UART 422–429
addresses 422t
divisor latch high register 424, 425t
divisor latch low register 424, 424t
FIFO control register 425t
interrupt control 429
line control register 425, 426t
line status register 426, 427t
receive buffer register 423, 424t
receive FIFO level register 426, 428t
register offsets 423t
status register 426, 427t
transmit FIFO level register 426, 428t
transmit halt register 428, 428t
transmit holding register 424, 424t
Raspberry Pi UART0 413–418
assembly functions for 422
basic programming for 418–422
control register 416, 417t
data register 413, 414t
flags register bits 414, 415t
fractional baud rate divisor 414, 416t
integer baud rate divisor 414, 416t
interrupt control 417
line control register bits 416, 416t
receive status register/error clear register 414, 415t
register map 413t
UART 410–412
Serial Peripheral Interface (SPI) functions 382
Shift instructions, NEON 329–334
saturating shift right by immediate 332–333
shift and insert 333–334
shift left by immediate 329–330
shift left/right by variable 330–331
shift right by immediate 331–332
Sine function 
ARM assembly implementation 251, 257
battery powered systems 260
double precision software float C 259
double precision VFP C 260
factorial terms, formats and constants for 249–251
formats for powers of x 248–249
intermediate calculations 251
NEON 354–358, 357t
double precision 355, 357
performance comparison 357–358, 357t
single precision 354–355
performance comparison 259–260
performance implementations 259t
properties 247–248
scalar implementation 286–287
single precision software float C 259
single precision VFP C 259
sinq 248
table printing 251, 258
32-bit fixed point assembly 259
32-bit fixed point C 259
vector implementation 289, 291
VFP 
performances 291, 292t
scalar mode 285–286
vector mode 287–291
Single instruction multiple data (SIMD) instructions 5
Single-precision floating point number 
fixed point to 284–285, 321–322
half-precision to 322
IEEE 754 245
sine function 354–355
Sorting 
linked list 147
by word frequency 147–150
Spaghetti code 100
Special instructions, ARM 
accessing CPSR and SPSR 91
count leading zeros 90
software interrupt 91–92
thumb mode 92–93
Stack and Heap segments 28–29
Status register 
ARM process 433f
pcDuino UART 426, 427t
Structured programming 
aggregate data types 123–131
arrays 124–125
arrays of structured data 126–131
structured data 124–126
description 99–100
iteration 104–108
for loop 106–108
post-test loop 106
pre-test loop 105
selection 101–104
complex selection 103–104
using branch instructions 102
using conditional execution 101–102
sequencing 100–101
subroutines 108–122
advantages 109
automatic variables 118–119
calling 113–117
disadvantages 110
passing parameters 110–113
recursive functions 119–122
standard C library functions 110
writing 117–118
Subtraction 
by addition 172
in decimal and binary 173b
fixed-point operation 231–232
floating point operation 246–247
ten’s complement 172b
vector 335–337
VFP 278
Swap vectors 315–316

T

Table lookup 317–319
Text section, memory 28–29
Therac-25 
for cancer 161
design flaws 163–165
double pass accelerator 161
history of 162–163
overdose 162–163
X-ray therapy 161
Three address instruction 80
Transmit FIFO level register 426, 428t
Transmit halt register 428, 428t
Transmit holding register 424, 424t
Transpose matrix 316–317

U

UCS Transformation Format-8-bit (UTF-8) 26–27
Unary operations 277–278
Universal Asynchronous Receiver/Transmitter (UART) 410–412
line driver 410
pcDuino 422–429
addresses 422t
divisor latch high register 424, 425t
divisor latch low register 424, 424t
FIFO control register 425t
interrupt control 429
line control register 425, 426t
line status register 426, 427t
receive buffer register 423, 424t
receive FIFO level register 426, 428t
register offsets 423t
status register 426, 427t
transmit FIFO level register 426, 428t
transmit halt register 428, 428t
transmit holding register 424, 424t
Raspberry Pi 413–418
assembly functions for 422
basic programming for 418–422
control register 416, 417t
data register 413, 414t
flags register bits 414, 415t
fractional baud rate divisor 414, 416t
integer baud rate divisor 414, 416t
interrupt control 417
line control register bits 416, 416t
receive status register/error clear register 414, 415t
register map 413t
standards 410
transmitter and receiver timings for 411f
Universal Character Set (UCS) code 26
Unzip vectors 319–320
User mode 432
UTF-8.  See UCS Transformation Format-8-bit (UTF-8)

V

Vector absolute comparison 324–325, 353–354
Vector floating point (VFP) 
code meanings for 271t
compare instruction 279
coprocessor 266–268
data conversion instructions 282–285
data movement instructions between 279–282
ARM register and VFP system register 282
two VFP register 279–280
VFP register and one integer register 280–281
VFP register and two integer register 281
data processing instructions 277–279
compare instruction 279
mathematical operations 278
unary operations 277–278
FPSCR 268–273
instructions 292
load and store instructions 274–277
overview 266–268
register usage rules 273–274
sine function 
performance 291, 292t
using scalar mode 285–286
using vector mode 287–291
user program registers 267f
Vectors 268
addition and subtraction 335–337
change size of elements 311–312
comparison operation 323–324
FPSCR 272–273
sine function using 287–291
swapping 315–316
unzip 319–320
zip 319–320
Vector table 434–435, 435t
Vector test bits 325–326
VFP.  See Vector floating point (VFP)

W

wl_print_numerical function 147–150
Word frequency counts, ADT 
better performance 150–161
binary tree of 151f, 157f, 158f
C header for 141–142
C implementation 141–142, 145, 150–151, 157
C program to compute 140–141
makefile for 141–142, 146
revised makefile for 148–150
sorting by 147–150

Z

Zip vectors 319–320