Blackfin® Processor Instruction Set

Blackfin® Processor
Instruction Set Reference
Revision 3.0, June 2004

Part Number
82-000410-14
Analog Devices, Inc.

One Technology Way
Norwood, Mass. 02062-9106
a
Copyright Information
©2004 Analog Devices, Inc., ALL RIGHTS RESERVED. This document
may not be reproduced in any form without prior, express written consent
from Analog Devices, Inc.
Printed in the USA.
Disclaimer
Analog Devices, Inc. reserves the right to change this product without
prior notice. Information furnished by Analog Devices is believed to be
accurate and reliable. However, no responsibility is assumed by Analog
Devices for its use; nor for any infringement of patents or other rights of
third parties which may result from its use. No license is granted by impli-
cation or otherwise under the patent rights of Analog Devices, Inc.
Trademark and Service Mark Notice

The Analog Devices logo, VisualDSP++, Blackfin, and the Blackfin logo
are registered trademarks of Analog Devices, Inc.
All other brand and product names are trademarks or service marks of
their respective owners.
CONTENTS
PREFACE
Purpose of This Manual ................................................................ xiii
Intended Audience ........................................................................ xiii
Manual Contents ........................................................................... xiv
What’s New in This Manual ........................................................... xiv
Technical or Customer Support ....................................................... xv
Supported Processors ...................................................................... xvi
Product Information ..................................................................... xvii
MyAnalog.com ........................................................................ xvii
Processor Product Information ................................................. xvii
Related Documents ................................................................ xviii
Online Technical Documentation ............................................. xix
Accessing Documentation From VisualDSP++ ...................... xix
Accessing Documentation From Windows ............................. xx
Accessing Documentation From the Web ............................... xx
Printed Manuals ....................................................................... xxi
VisualDSP++ Documentation Set ......................................... xxi
Hardware Tools Manuals ...................................................... xxi
Processor Manuals ................................................................ xxi
Data Sheets .......................................................................... xxi
Conventions ................................................................................. xxii
INTRODUCTION
Manual Organization .................................................................... 1-1
Blackfin Processor Instruction Set Reference iii

CONTENTS
Syntax Conventions ...................................................................... 1-1

Case Sensitivity ....................................................................... 1-2
Free Format ............................................................................ 1-2
Instruction Delimiting ............................................................ 1-2
Comments .............................................................................. 1-3
Notation Conventions .................................................................. 1-4
Behavior Conventions ................................................................... 1-6
Glossary ....................................................................................... 1-6
Register Names ....................................................................... 1-6
Functional Units ..................................................................... 1-6
Arithmetic Status Flags ............................................................ 1-8
Fractional Convention .......................................................... 1-10
Saturation ............................................................................. 1-11
Rounding and Truncating ..................................................... 1-13
Automatic Circular Addressing .............................................. 1-15
PROGRAM FLOW CONTROL

Instruction Overview .................................................................... 2-1
Jump ............................................................................................ 2-2
IF CC JUMP ................................................................................ 2-5
Call .............................................................................................. 2-8
RTS, RTI, RTX, RTN, RTE (Return) ......................................... 2-10
LSETUP, LOOP ......................................................................... 2-13
iv Blackfin Processor Instruction Set Reference

CONTENTS
LOAD / STORE
Load Immediate ............................................................................ 3-3
Load Pointer Register .................................................................... 3-7
Load Data Register ...................................................................... 3-10
Load Half-Word – Zero-Extended ............................................... 3-15
Load Half-Word – Sign-Extended ................................................ 3-19
Load High Data Register Half ..................................................... 3-23
Load Low Data Register Half ...................................................... 3-27
Load Byte – Zero-Extended ......................................................... 3-31
Load Byte – Sign-Extended ......................................................... 3-34
Store Pointer Register .................................................................. 3-37
Store Data Register ..................................................................... 3-40
Store High Data Register Half ..................................................... 3-45
Store Low Data Register Half ...................................................... 3-49
Store Byte ................................................................................... 3-54
MOVE
Move Register ............................................................................... 4-2
Move Conditional ......................................................................... 4-8
Move Half to Full Word – Zero-Extended ................................... 4-10
Move Half to Full Word – Sign-Extended .................................... 4-13
Move Register Half ..................................................................... 4-15
Blackfin Processor Instruction Set Reference v

CONTENTS
Move Byte – Zero-Extended ....................................................... 4-23

Move Byte – Sign-Extended ........................................................ 4-25
STACK CONTROL
--SP (Push) ................................................................................... 5-2
--SP (Push Multiple) ..................................................................... 5-5
SP++ (Pop) ................................................................................... 5-8
SP++ (Pop Multiple) ................................................................... 5-12
LINK, UNLINK ........................................................................ 5-17
CONTROL CODE BIT MANAGEMENT

Compare Data Register ................................................................. 6-2
Compare Pointer .......................................................................... 6-6
Compare Accumulator .................................................................. 6-9
Move CC ................................................................................... 6-12
Negate CC ................................................................................. 6-15
LOGICAL OPERATIONS
& (AND) ..................................................................................... 7-2
~ (NOT One’s Complement) ........................................................ 7-4
| (OR) .......................................................................................... 7-6
^ (Exclusive-OR) .......................................................................... 7-8
BXORSHIFT, BXOR ................................................................. 7-10
vi Blackfin Processor Instruction Set Reference

CONTENTS
BIT OPERATIONS
BITCLR ....................................................................................... 8-2
BITSET ........................................................................................ 8-4
BITTGL ....................................................................................... 8-6
BITTST ....................................................................................... 8-8
DEPOSIT .................................................................................. 8-10
EXTRACT ................................................................................. 8-16
BITMUX .................................................................................... 8-21
ONES (One’s Population Count) ................................................ 8-26
SHIFT/ROTATE OPERATIONS
Add with Shift .............................................................................. 9-2
Shift with Add .............................................................................. 9-5
Arithmetic Shift ............................................................................ 9-7
Logical Shift ............................................................................... 9-14
ROT (Rotate) ............................................................................. 9-21
ARITHMETIC OPERATIONS
Instruction Overview .................................................................. 10-2
ABS ............................................................................................ 10-3
Add ............................................................................................ 10-6
Add/Subtract – Prescale Down .................................................. 10-10
Add/Subtract – Prescale Up ....................................................... 10-13
Blackfin Processor Instruction Set Reference vii

CONTENTS
Add Immediate ......................................................................... 10-16

DIVS, DIVQ (Divide Primitive) ............................................... 10-19
EXPADJ ................................................................................... 10-27
MAX ........................................................................................ 10-31
MIN ........................................................................................ 10-34
Modify – Decrement ................................................................ 10-37
Modify – Increment .................................................................. 10-40
Multiply 16-Bit Operands ......................................................... 10-46
Multiply 32-Bit Operands ......................................................... 10-54
Multiply and Multiply-Accumulate to Accumulator ................... 10-56
Multiply and Multiply-Accumulate to Half-Register .................. 10-61
Multiply and Multiply-Accumulate to Data Register .................. 10-70
Negate (Two’s Complement) ..................................................... 10-76
RND (Round to Half-Word) .................................................... 10-80
Saturate .................................................................................... 10-83
SIGNBITS ............................................................................... 10-86
Subtract ................................................................................... 10-89
Subtract Immediate .................................................................. 10-93
EXTERNAL EVENT MANAGEMENT

Idle ............................................................................................ 11-3
Core Synchronize ....................................................................... 11-5
System Synchronize .................................................................... 11-8
EMUEXCPT (Force Emulation) ............................................... 11-11
viii Blackfin Processor Instruction Set Reference

CONTENTS
Disable Interrupts ..................................................................... 11-13

Enable Interrupts ...................................................................... 11-15
RAISE (Force Interrupt / Reset) ................................................ 11-17
EXCPT (Force Exception) ......................................................... 11-20
Test and Set Byte (Atomic) ........................................................ 11-22
No Op ...................................................................................... 11-25
CACHE CONTROL
PREFETCH ............................................................................... 12-2
FLUSH ....................................................................................... 12-4
FLUSHINV ................................................................................ 12-6
IFLUSH ..................................................................................... 12-8
VIDEO PIXEL OPERATIONS

ALIGN8, ALIGN16, ALIGN24 .................................................. 13-3
DISALGNEXCPT ...................................................................... 13-6
BYTEOP3P (Dual 16-Bit Add / Clip) ......................................... 13-8
Dual 16-Bit Accumulator Extraction with Addition ................... 13-13
BYTEOP16P (Quad 8-Bit Add) ................................................ 13-15
BYTEOP1P (Quad 8-Bit Average – Byte) .................................. 13-19
BYTEOP2P (Quad 8-Bit Average – Half-Word) ........................ 13-24
BYTEPACK (Quad 8-Bit Pack) ................................................. 13-30
BYTEOP16M (Quad 8-Bit Subtract) ........................................ 13-33
Blackfin Processor Instruction Set Reference ix

CONTENTS
SAA (Quad 8-Bit Subtract-Absolute-Accumulate) ...................... 13-37

BYTEUNPACK (Quad 8-Bit Unpack) ...................................... 13-42
VECTOR OPERATIONS
Add on Sign ............................................................................... 14-3
VIT_MAX (Compare-Select) ...................................................... 14-9
Vector ABS ............................................................................... 14-16
Vector Add / Subtract ............................................................... 14-19
Vector Arithmetic Shift ............................................................. 14-25
Vector Logical Shift .................................................................. 14-30
Vector MAX ............................................................................. 14-34
Vector MIN .............................................................................. 14-37
Vector Multiply ........................................................................ 14-40
Vector Multiply and Multiply-Accumulate ................................ 14-43
Vector Negate (Two’s Complement) .......................................... 14-48
Vector PACK ............................................................................ 14-50
Vector SEARCH ....................................................................... 14-52
ISSUING PARALLEL INSTRUCTIONS

Supported Parallel Combinations ................................................ 15-1
Parallel Issue Syntax .................................................................... 15-2
32-Bit ALU/MAC Instructions ................................................... 15-2
16-Bit Instructions ..................................................................... 15-6
Examples .................................................................................... 15-8
x Blackfin Processor Instruction Set Reference

CONTENTS
ADSP-BF535 FLAGS
INDEX
Blackfin Processor Instruction Set Reference xi

CONTENTS
xii Blackfin Processor Instruction Set Reference

Preface
PREFACE
Thank you for purchasing and developing systems using Blackfin® pro-
cessors from Analog Devices.
Purpose of This Manual

The Blackfin ProcessorInstruction Set Reference contains information about
the DSP architecture and DSP assembly language for Blackfin processors.
The manual provides information on how assembly instructions execute
on the Blackfin processor’s architecture along with reference information
about DSP operations.
Intended Audience
The primary audience for this manual is a programmer who is familiar
with Analog Devices processors. This manual assumes that the audience
has a working knowledge of the appropriate processor architecture and
instruction set. Programmers who are unfamiliar with Analog Devices
processors can use this manual, but should supplement it with other texts
(such as the appropriate hardware reference manuals and data sheets) that
describe your target architecture.
Blackfin Processor Instruction Set Reference xiii

Manual Contents
Manual Contents
The manual consists of:
• Chapter 1, Introduction
Provides a general description of the instruction syntax and nota-
tion conventions.
• Chapters 2–14, Program Flow Control, Load / Store, Move, Stack
Control, Control Code Bit Management, Logical Operations, Bit
Operations, Shift/Rotate Operations, Arithmetic Operations,
External Event Management, Cache Control, Video Pixel Opera-
tions, and Vector Operations
Provide descriptions of assembly language instructions and describe
their execution.
• Chapter 15, Issuing Parallel Instructions
Provides a description of parallel instruction operations and shows
how to use parallel instruction syntax.
• Appendix A, ADSP-BF535 Flags
Provides a description of the status flag bits for the ADSP-BF535
processor only.
What’s New in This Manual

This is the third revision of the Blackfin Processor Instruction Set Reference.
Changes to this book from the second revision include corrections of
typographic errors and reported document errata.
xiv Blackfin Processor Instruction Set Reference

Preface
Technical or Customer Support

You can reach Analog Devices, Inc. Customer Support in the following
ways:
• Visit the Embedded Processing and DSP products Web site at
http://www.analog.com/processors/technicalSupport
• E-mail tools questions to

dsptools.support@analog.com
• E-mail processor questions to

dsp.support@analog.com
• Phone questions to 1-800-ANALOGD

• Contact your Analog Devices, Inc. local sales office or authorized
distributor
• Send questions by mail to:
Analog Devices, Inc.
One Technology Way
P.O. Box 9106
Norwood, MA 02062-9106
USA
Blackfin Processor Instruction Set Reference xv

Supported Processors
Supported Processors
The following is the list of Analog Devices, Inc. processors supported in
VisualDSP++®.
TigerSHARC (ADSP-TSxxx) Processors
The name “TigerSHARC” refers to a family of floating-point and
fixed-point [8-bit, 16-bit, and 32-bit] processors. VisualDSP++ currently
supports the following TigerSHARC processors:
ADSP-TS101 , ADSP-TS201, ADSP-TS202, and ADSP-TS203
SHARC (ADSP-21xxx) Processors
The name “SHARC” refers to a family of high-performance, 32-bit,
floating-point processors that can be used in speech, sound, graphics, and
imaging applications. VisualDSP++ currently supports the following
SHARC processors:
ADSP-21020, ADSP-21060, ADSP-21061, ADSP-21062,
ADSP-21065L, ADSP-21160, ADSP-21161, ADSP-21261,
ADSP-21262, ADSP-21266, ADSP-21267, ADSP-21363, ADSP-21364,
and ADSP-21365
Blackfin (ADSP-BFxxx) Processors
The name “Blackfin” refers to a family of 16-bit, embedded processors.
VisualDSP++ currently supports the following Blackfin processors:
ADSP-BF531, ADSP-BF532 (formerly ADSP-21532), ADSP-BF533,
ADSP-BF535 (formerly ADSP-21535), ADSP-BF561, AD6532, and
AD90747
xvi Blackfin Processor Instruction Set Reference

Preface
Product Information
You can obtain product information from the Analog Devices Web site,
from the product CD-ROM, or from the printed publications (manuals).
Analog Devices is online at www.analog.com. Our Web site provides infor-
mation about a broad range of products—analog integrated circuits,
amplifiers, converters, and digital signal processors.
MyAnalog.com
MyAnalog.com is a free feature of the Analog Devices Web site that allows
customization of a Web page to display only the latest information on
products you are interested in. You can also choose to receive weekly
e-mail notifications containing updates to the Web pages that meet your
interests. MyAnalog.com provides access to books, application notes, data
sheets, code examples, and more.
Registration
Visit www.myanalog.com to sign up. Click Register to use MyAnalog.com.
Registration takes about five minutes and serves as a means to select the
information you want to receive.
If you are already a registered user, just log on. Your user name is your
e-mail address.
Processor Product Information

For information on embedded processors and DSPs, visit our Web site at
www.analog.com/processors, which provides access to technical publica-
tions, data sheets, application notes, product overviews, and product
announcements.
Blackfin Processor Instruction Set Reference xvii

Product Information
You may also obtain additional information about Analog Devices and its
products in any of the following ways.
• E-mail questions or requests for information to
dsp.support@analog.com
• Fax questions or requests for information to

1-781-461-3010 (North America)
089/76 903-557 (Europe)
• Access the FTP Web site at
ftp ftp.analog.com or ftp 137.71.23.21
ftp://ftp.analog.com
Related Documents
For information on product related development software and Analog
Devices processors, see these publications:
• VisualDSP++ User's Guide for Blackfin Processors
• VisualDSP++ C/C++ Compiler and Library Manual for Blackfin
Processors
• VisualDSP++ Assembler and Preprocessor Manual for Blackfin
Processors
• VisualDSP++ Linker and Utilities Manual for Blackfin Processors
• VisualDSP++ Kernel (VDK) User's Guide
Visit the Technical Library Web site to access all processor and tools
manuals and data sheets:
http://www.analog.com/processors/resources/technicalLibrary
xviii Blackfin Processor Instruction Set Reference

Preface
Online Technical Documentation

Online documentation comprises the VisualDSP++ Help system, software
tools manuals, hardware tools manuals, processor manuals, the Dinkum
Abridged C++ library, and Flexible License Manager (FlexLM) network
license manager software documentation. You can easily search across the
entire VisualDSP++ documentation set for any topic of interest. For easy
printing, supplementary .PDF files of most manuals are also provided.
Each documentation file type is described as follows.
File Description
.CHM Help system files and manuals in Help format
.HTM or Dinkum Abridged C++ library and FlexLM network license manager software doc-
.HTML umentation. Viewing and printing the .HTML files requires a browser, such as
Internet Explorer 4.0 (or higher).
.PDF VisualDSP++ and processor manuals in Portable Documentation Format (PDF).
Viewing and printing the .PDF files requires a PDF reader, such as Adobe Acrobat
Reader (4.0 or higher).
If documentation is not installed on your system as part of the software

installation, you can add it from the VisualDSP++ CD-ROM at any time
by running the Tools installation. Access the online documentation from
the VisualDSP++ environment, Windows® Explorer, or the Analog
Devices Web site.
Accessing Documentation From VisualDSP++

From the VisualDSP++ environment:
• Access VisualDSP++ online Help from the Help menu’s Contents,
Search, and Index commands.
• Open online Help from context-sensitive user interface items (tool-
bar buttons, menu commands, and windows).
Blackfin Processor Instruction Set Reference xix

Product Information
Accessing Documentation From Windows

In addition to any shortcuts you may have constructed, there are many
ways to open VisualDSP++ online Help or the supplementary documenta-
tion from Windows.
Help system files (.CHM) are located in the Help folder, and .PDF files are
located in the Docs folder of your VisualDSP++ installation CD-ROM.
The Docs folder also contains the Dinkum Abridged C++ library and the
FlexLM network license manager software documentation.
Using Windows Explorer
• Double-click the vdsp-help.chm file, which is the master Help sys-
tem, to access all the other .CHM files.
• Double-click any file that is part of the VisualDSP++ documenta-
tion set.
Using the Windows Start Button
• Access VisualDSP++ online Help by clicking the Start button and
choosing Programs, Analog Devices, VisualDSP++, and
VisualDSP++ Documentation.
• Access the .PDF files by clicking the Start button and choosing
Programs, Analog Devices, VisualDSP++, Documentation for
Printing, and the name of the book.
Accessing Documentation From the Web

Download manuals at the following Web site:
http://www.analog.com/processors/resources/technicalLibrary/manuals
Select a processor family and book title. Download archive (.ZIP) files, one
for each manual. Use any archive management software, such as WinZip,
to decompress downloaded files.
xx Blackfin Processor Instruction Set Reference

Preface
Printed Manuals
For general questions regarding literature ordering, call the Literature
Center at 1-800-ANALOGD (1-800-262-5643) and follow the prompts.
VisualDSP++ Documentation Set

To purchase VisualDSP++ manuals, call 1-603-883-2430. The manuals
may be purchased only as a kit.
If you do not have an account with Analog Devices, you are referred to
Analog Devices distributors. For information on our distributors, log onto
http://www.analog.com/salesdir/continent.asp.
Hardware Tools Manuals

To purchase EZ-KIT Lite™ and In-Circuit Emulator (ICE) manuals,
call 1-603-883-2430. The manuals may be ordered by title or by product
number located on the back cover of each manual.
Processor Manuals
Hardware reference and instruction set reference manuals may be ordered
through the Literature Center at 1-800-ANALOGD (1-800-262-5643),
or downloaded from the Analog Devices Web site. Manuals may be
ordered by title or by product number located on the back cover of each
manual.
Data Sheets
All data sheets (preliminary and production) may be downloaded from the
Analog Devices Web site. Only production (final) data sheets (Rev. 0, A,
B, C, and so on) can be obtained from the Literature Center at
1-800-ANALOGD (1-800-262-5643); they also can be downloaded from
the Web site.
Blackfin Processor Instruction Set Reference xxi

Conventions
To have a data sheet faxed to you, call the Analog Devices Faxback System
at 1-800-446-6212. Follow the prompts and a list of data sheet code
numbers will be faxed to you. If the data sheet you want is not listed,
check for it on the Web site.
Conventions
Text conventions used in this manual are identified and described as
follows.
Example Description
Close command Titles in reference sections indicate the location of an item within the
(File menu) VisualDSP++ environment’s menu system. For example, the Close
command appears on the File menu.
this|that Alternative items in syntax descriptions are delimited with a vertical

bar; read the example as this or that. One or the other is required.
{this | that} Optional items in syntax descriptions appear within curly braces; read
the example as an optional this or that.
[{({S|SU})}] Optional items for some lists may appear within parenthesis. If an
option is chosen, the parenthesis must be used (for example, (S)). If
no option is chosen, omit the parenthsis.
.SECTION Commands, directives, keywords, and feature names are in text with
letter gothic font.
filename Non-keyword placeholders appear in text with italic style format.
This symbol indicates a note that provides supplementary information

on a related topic. In the online version of this book, the word Note
appears instead of this symbol.
This symbol indicates a warning that advises on an inappropriate usage

of the product that could lead to undesirable results or product dam-
age. In the online version of this book, the word Warning appears
instead of this symbol.
xxii Blackfin Processor Instruction Set Reference

Preface
L Additional conventions, which apply only to specific chapters, may

appear throughout this document.
Blackfin Processor Instruction Set Reference xxiii

Conventions
xxiv Blackfin Processor Instruction Set Reference

1 INTRODUCTION
This Blackfin Processor Instruction Set Reference provides details on the

assembly language instructions used by the Micro Signal Architecture
(MSA) core developed jointly by Analog Devices, Inc. and Intel Corpora-
tion. This section points out some of the conventions used in this
document.
Manual Organization
The instructions are grouped according to their functions. Within group-
ings, the instructions are generally arranged alphabetically unless a
functional relationship makes another order clearer for the programmer.
One such example of nonalphabetic ordering is the Load/Store chapter
where the Load Pointer Register appears before a pile of seven Load Data
Register derivations. The instructions are listed at the beginning of each
chapter in the order they appear.
The instruction groups, or chapters, are arranged according to complexity,
beginning with the basic Program Flow Control and Load/Store chapters
and progressing to Video Pixel Operations and Vector Operations.
Syntax Conventions
The Blackfin processor instruction set supports several syntactic conven-
tions that appear throughout this document. Those conventions are given
below.
Blackfin Processor Instruction Set Reference 1-1

Syntax Conventions
Case Sensitivity
The instruction syntax is case insensitive. Upper and lower case letters can
be used and intermixed arbitrarily.
The assembler treats register names and instruction keywords in a
case-insensitive manner. User identifiers are case sensitive. Thus, R3.l,
R3.L, r3.l, r3.L are all valid, equivalent input to the assembler.
This manual shows register names and instruction keywords in examples

using lower case. Otherwise, in explanations and descriptions, this manual
uses upper case to help the register names and keywords stand out among
text.
Free Format
Assembler input is free format, and may appear anywhere on the line. One
instruction may extend across multiple lines, or more than one instruction
may appear on the same line. White space (space, tab, comments, or new-
line) may appear anywhere between tokens. A token must not have
embedded spaces. Tokens include numbers, register names, keywords,
user identifiers, and also some multicharacter special symbols like “+=”,
“/*”, or “||”.
Instruction Delimiting
A semicolon must terminate every instruction. Several instructions can be
placed together on a single line at the programmer’s discretion, provided
each instruction ends with a semicolon.
1-2 Blackfin Processor Instruction Set Reference

Introduction
Each complete instruction must end with a semicolon. Sometimes, a com-

plete instruction will consist of more than one operation. There are two
cases where this occurs.
• Two general operations are combined. Normally a comma sepa-
rates the different parts, as in
a0 = r3.h * r2.l , a1 = r3.l * r2.h ;
• A general instruction is combined with one or two memory refer-

ences for joint issue. The latter portions are set off by a “||” token.
For example,
a0 = r3.h * r2.l || r1 = [p3++] || r4 = [i2++] ;
Comments
The assembler supports various kinds of comments, including the
following.
• End of line: A double forward slash token (“//”) indicates the
beginning of a comment that concludes at the next newline
character.
• General comment: A general comment begins with the token “/*”
and ends with “*/”. It may contain any characters and extend over
multiple lines.
Comments are not recursive; if the assembler sees a “/*” within a general
comment, it issues an assembler warning. A comment functions as white
space.

Notation Conventions
Notation Conventions
This manual and the assembler use the following conventions.
• Register names are alphabetical, followed by a number in cases
where there are more than one register in a logical group. Thus,
examples include ASTAT, FP, R3, and M2.
• Register names are reserved and may not be used as program
identifiers.
• Some operations (such as “Move Register”) require a register pair.
Register pairs are always Data Registers and are denoted using a
colon, e.g., R3:2. The larger number must be written first. Note
that the hardware supports only odd-even pairs, e.g., R7:6, R5:4,
R3:2, and R1:0.
• Some instructions (such as “--SP (Push Multiple)”) require a group

of adjacent registers. Adjacent registers are denoted in syntax by the
range enclosed in parentheses and separated by a colon, e.g.,
(R7:3). Again, the larger number appears first.
• Portions of a particular register may be individually specified. This

is written in syntax with a dot (“.”) following the register name,
then a letter denoting the desired portion. For 32-bit registers, “.H”
denotes the most-significant (“High”) portion, “.L” denotes the
least-significant portion. The subdivisions of the 40-bit registers
are described later.
Register names are reserved and may not be used as program identifiers.

Introduction
This manual uses the following conventions.

• When there is a choice of any one register within a register group,
this manual shows the register set using an en-dash (“–”). For
example, “R7–0” in text means that any one of the eight data regis-
ters (R7, R6, R5, R4, R3, R2, R1, or R0) can be used in syntax.
• Immediate values are designated as “imm” with the following
modifiers.
• “imm” indicates a signed value; for example, imm7.
• The “u” prefix indicates an unsigned value; for example,
uimm4.
• The decimal number indicates how many bits the value can
include; for example, imm5 is a 5-bit value.
• Any alignment requirements are designated by an optional
“m” suffix followed by a number; for example, uimm16m2 is
an unsigned, 16-bit integer that must be an even number,
and imm7m4 is a signed, 7-bit integer that must be a multiple
of 4.
• PC-relative, signed values are designated as “pcrel” with the
following modifiers:
• the decimal number indicates how many bits the
value can include; for example, pcrel5 is a 5-bit
value.
• any alignment requirements are designated by an
optional “m” suffix followed by a number; for exam-
ple, pcrel13m2 is a 13-bit integer that must be an
even number.

Behavior Conventions
• Loop PC-relative, signed values are designated as “lppcrel”

with the following modifiers:
• the decimal number indicates how many bits the
value can include; for example, lppcrel5 is a 5-bit
value.
• any alignment requirements are designated by an
optional “m” suffix followed by a number; for exam-
ple, lppcrel11m2 is an 11-bit integer that must be an
even number.
Behavior Conventions
All operations that produce a result in an Accumulator saturate to a 40-bit
quantity unless noted otherwise. See “Saturation” on page 1-11 for a
description of saturation behavior.
Glossary
The following terms appear throughout this document. Without trying to
explain the Blackfin processor, here are the terms used with their defini-
tions. See the Blackfin Processor Hardware Reference for your specific
product for more details on the architecture.
Register Names
The architecture includes the registers shown in Table 1-1.
Functional Units
The architecture includes the three processor sections shown in Table 1-2.

Introduction
Table 1-1. Registers

Register Description
Accumulators The set of 40-bit registers A1 and A0 that normally contain data that is being
manipulated. Each Accumulator can be accessed in five ways: as one 40-bit reg-
ister, as one 32-bit register (designated as A1.W or A0.W), as two 16-bit regis-
ters similar to Data Registers (designated as A1.H, A1.L, A0.H, or A0.L) and as
one 8-bit register (designated A1.X or A0.X) for the bits that extend beyond bit
31.
Data The set of 32-bit registers (R0, R1, R2, R3, R4, R5, R6, and R7) that normally
Registers contain data for manipulation. Abbreviated D-register or Dreg. Data Registers
can be accessed as 32-bit registers, or optionally as two independent 16-bit reg-
isters. The least significant 16 bits of each register is called the “low” half and is
designated with “.L” following the register name. The most significant 16 bit is
called the “high” half and is designated with “.H” following the name. Example:
R7.L, r2.h, r4.L, R0.h.
Pointer The set of 32-bit registers (P0, P1, P2, P3, P4, P5, including SP and FP) that
Registers normally contain byte addresses of data structures. Accessed only as a 32-bit reg-
ister. Abbreviated P-register or Preg. Example: p2, p5, fp, sp.
Stack Pointer SP; contains the 32-bit address of the last occupied byte location in the stack.
The stack grows by decrementing the Stack Pointer. A subset of the Pointer Reg-
isters.
Frame FP; contains the 32-bit address of the previous Frame Pointer in the stack,
Pointer located at the top of a frame. A subset of the Pointer Registers.
Loop Top LT0 and LT1; contains 32-bit address of the top of a zero overhead loop.
Loop Count LC0 and LC1; contains 32-bit counter of the zero overhead loop executions.
Loop Bottom LB0 and LB1; contains 32-bit address of the bottom of a zero overhead loop.
Index The set of 32-bit registers I0, I1, I2, I3 that normally contain byte addresses of
Register data structures. Abbreviated I-register or Ireg.
Modify The set of 32-bit registers M0, M1, M2, M3 that normally contain offset values
Registers that are added or subtracted to one of the Index Registers. Abbreviated as Mreg.

Glossary
Table 1-1. Registers (Cont’d)

Register Description
Length The set of 32-bit registers L0, L1, L2, L3 that normally contain the length (in
Registers bytes) of the circular buffer. Abbreviated as Lreg. Clear Lreg to disable circular
addressing for the corresponding Ireg. Example: Clear L3 to disable circular
addressing for I3.
Base The set of 32-bit registers B0, B1, B2, B3 that normally contain the base
Registers address (in bytes) of the circular buffer. Abbreviated as Breg.
Table 1-2. Processor Sections

Processor Description
Data Address Calculates the effective address for indirect and indexed memory
Generator (DAG) accesses. Consists of two sections–DAG0 and DAG1.
Multiply and Performs the arithmetic functions on data. Consists of two sections
Accumulate Unit (MAC0 and MAC1)–each associated with an Accumulator (A0 and A1,
(MAC) respectively).
Arithmetic Logical Performs arithmetic computations and binary shifts on data. Operates
Unit (ALU) on the Data Registers and Accumulators. Consists of two units (ALU0
and ALU1), each associated with an Accumulator (A0 and A1, respec-
tively). Each ALU operates in conjunction with a Multiply and Accu-
mulate Unit.
Arithmetic Status Flags

The MSA includes 12 arithmetic status flags that indicate specific results
of a prior operation. These flags reside in the Arithmetic Status (ASTAT)
Register. A summary of the flags appears below. All flags are active high.
Instructions regarding P-registers, I-registers, L-registers, M-registers, or
B-registers do not affect flags.

Introduction
See the Blackfin Processor Hardware Reference for your specific product for
more details on the architecture.
Table 1-3. Arithmetic Status Flag Summary

Flag Description
AC0 Carry (ALU0)
AC0_COPY Carry (ALU0), copy
AC1 Carry (ALU1)
AN Negative
AQ Quotient
AV0 Accumulator 0 Overflow
AVS0 Accumulator 0 Sticky Overflow

Set when AV0 is set, but remains set until explicitly cleared by user code.
AV1 Accumulator 1 Overflow
AVS1 Accumulator 1 Sticky Overflow

Set when AV1 is set, but remains set until explicitly cleared by user code.
AZ Zero
CC Control Code bit

Multipurpose flag set, cleared and tested by specific instructions.
V Overflow for Data Register results
V_COPY Overflow for Data Register results. copy

VS Sticky Overflow for Data Register results
Set when V is set, but remains set until explicitly cleared by user code.
L The ADSP-BF535 processor has fewer flags and some flags

ASTAT
operate differently than subsequent Blackfin family products. For
more information on the ADSP-BF535 status flags, see Table A-1
on page A-2.

Glossary
Fractional Convention
Fractional numbers include subinteger components less than ±1. Whereas
decimal fractions appear to the right of a decimal point, binary fractions
appear to the right of a binal point.
In DSP instructions that assume placement of a binal point, for example
in computing sign bits for normalization or for alignment purposes, the
binal point convention depends on the size of the register being used as
shown in Table 1-4 and Figure 1-1 on page 1-11.
L This processor does not represent fractional values in 8-bit

registers.
Table 1-4. Fractional Conventions
Fractional
Extension
Registers Size Format Notation Sign
Bits
Bits
Bit
40-bit registers Signed Fractional 9.31 1 8 31
Unsigned Fractional 8.32 0 8 32

Introduction
40-bit accumulator
S 8-bit extension 31-bit fraction
32-bit register
S 31-bit fraction
16-bit register half

S 15-bit fraction
binal point alignment
Figure 1-1. Conventional Placement of Binal Point Within Signed Frac-

tional 40-, 32-, and 16-Bit Data
Saturation
When the result of an arithmetic operation exceeds the range of the desti-
nation register, important information can be lost.
Saturation is a technique used to contain the quantity within the values
that the destination register can represent. When a value is computed that
exceeds the capacity of the destination register, then the value written to
the register is the largest value that the register can hold with the same sign
as the original.
• If an operation would otherwise cause a positive value to overflow
and become negative, instead, saturation limits the result to the
maximum positive value for the size register being used.
• Conversely, if an operation would otherwise cause a negative value
to overflow and become positive, saturation limits the result to the
maximum negative value for the register size.
The overflow arithmetic flag is never set by an operation that enforces
saturation.

Glossary
The maximum positive value in a 16-bit register is 0x7FFF. The maxi-

mum negative value is 0x8000. For a signed two’s complement 1.15
fractional notation, the allowable range is –1 through (1–2–15).
The maximum positive value in a 32-bit register is 0x7FFF FFFF. The
maximum negative value is 0x8000 0000. For a signed two’s complement
fractional data in 1.31 format, the range of values that the register can
hold are –1 through (1–2–31).
The maximum positive value in a 40-bit register is 0x7F FFFF FFFF. The
maximum negative value is 0x80 0000 0000. For a signed two’s comple-
ment 9.31 fractional notation, the range of values that can be represented
is –256 through (256–2–31).
For example, if a 16-bit register containing 0x1000 (decimal integer
+4096) was shifted left 3 places without saturation, it would overflow to
0x8000 (decimal –32,768). With saturation, however, a left shift of 3 or
more places would always produce the largest positive 16-bit number,
0x7FFF (decimal +32,767).
Another common example is copying the lower half of a 32-bit register
into a 16-bit register. If the 32-bit register contains 0xFEED 0ACE and
the lower half of this negative number is copied into a 16-bit register with-
out saturation, the result is 0x0ACE, a positive number. But if saturation
is enforced, the 16-bit result maintains its negative sign and becomes
0x8000.
The MSA implements 40-bit saturation for all arithmetic operations that
write an Accumulator destination except as noted in the individual
instruction descriptions when an optional 32-bit saturation mode can
constrain a 40-bit Accumulator to the 32-bit register range. The MSA per-
forms 32-bit saturation for 32-bit register destinations only as noted in the
instruction descriptions.
Overflow is the alternative to saturation. The number is allowed to simply
exceed its bounds and lose its most significant bit(s); only the lowest
(least-significant) portion of the number can be retained. Overflow can

Introduction
occur when a 40-bit value is written to a 32-bit destination. If there was

any useful information in the upper 8 bits of the 40-bit value, then infor-
mation is lost in the process. Some processor instructions report overflow
conditions in the arithmetic flags, as noted in the instruction descriptions.
The arithmetic flags reside in the Arithmetic Status (ASTAT) Register. See
the Blackfin Processor Hardware Reference for your specific product for
more details on the ASTAT Register.
Rounding and Truncating

Rounding is a means of reducing the precision of a number by removing a
lower-order range of bits from that number’s representation and possibly
modifying the remaining portion of the number to more accurately repre-
sent its former value. For example, the original number will have N bits of
precision, whereas the new number will have only M bits of precision
(where N>M), so N-M bits of precision are removed from the number in
the process of rounding.
The round-to-nearest method returns the closest number to the original.
By convention, an original number lying exactly halfway between two
numbers always rounds up to the larger of the two. For example, when
rounding the 3-bit, two’s complement fraction 0.25 (binary 0.01) to the
nearest 2-bit two’s complement fraction, this method returns 0.5 (binary
0.1). The original fraction lies exactly midway between 0.5 and 0.0
(binary 0.0), so this method rounds up. Because it always rounds up, this
method is called biased rounding.
The convergent rounding method also returns the closest number to the
original. However, in cases where the original number lies exactly halfway
between two numbers, this method returns the nearest even number, the
one containing an LSB of 0. So for the example above, the result would be
0.0, since that is the even numbered choice of 0.5 and 0.0. Since it rounds
up and down based on the surrounding values, this method is called unbi-
ased rounding.

Glossary
Some instructions for this processor support biased and unbiased round-
ing. The RND_MOD bit in the Arithmetic Status (ASTAT) Register determines
which mode is used. See the Blackfin Processor Hardware Reference for your
specific product for more details on the ASTAT Register.
Another common way to reduce the significant bits representing a number
is to simply mask off the N-M lower bits. This process is known as trunca-
tion and results in a relatively large bias.
Figure 1-2 shows other examples of rounding and truncation methods.
0 1 0 0 1 0 0 0 original 8-bit number (0.5625)
0 1 0 1 4-bit biased rounding (0.625)
0 1 0 0 4-bit unbiased rounding (0.5)
0 1 0 0 4-bit truncation (0.5)
0 1 0 0 1 0 1 0 original 8-bit number (0.578125)
0 1 0 1 4-bit biased rounding (0.625)
0 1 0 1 4-bit unbiased rounding (0.625)
0 1 0 0 4-bit truncation (0.5)
Figure 1-2. Two Examples Showing an 8-Bit Number Reduced to 4 Bits of

Precision

Introduction
Automatic Circular Addressing

The Blackfin processor provides an optional circular (or “modulo”)
addressing feature that increments an Index Register (Ireg) through a pre-
defined address range, then automatically resets the Ireg to repeat that
range. This feature improves input/output loop performance by eliminat-
ing the need to manually reinitialize the address index pointer each time.
Circular addressing is useful, for instance, when repetitively loading or
storing a string of fixed-sized data blocks.
The circular buffer contents must meet the following conditions:
• The maximum length of a circular buffer (that is, the value held in
any L register) must be an unsigned number with magnitude less
than 231.
• The magnitude of the modifier should be less than the length of
the circular buffer.
• The initial location of the pointer I should be within the circular
buffer defined by the base B and length L.
If any of these conditions is not satisfied, then processor behavior is not
specified.
There are two elements of automatic circular addressing:
• Indexed address instructions
• Four sets of circular addressing buffer registers composed of one
each Ireg, Breg, and Lreg (i.e., I0/B0/L0, I1/B1/L1, I2/B2/L2, and
I3/B3/L3)
To qualify for circular addressing, the indexed address instruction must

explicitly modify an Index Register. Some indexed address instructions use
a Modify Register (Mreg) to increment the Ireg value. In that case, any
Mreg can be used to increment any Ireg. The Ireg used in the instruction
specifies which of the four circular buffer sets to use.

Glossary
The circular buffer registers define the length (Lreg) of the data block in
bytes and the base (Breg) address to reinitialize the Ireg.
Some instructions modify an Index Register without using it for address-
ing; for example, the Add Immediate and Modify – Decrement
instructions. Such instructions are still affected by circular addressing, if
enabled.
Disable circular addressing for an Ireg by clearing the Lreg that corre-
sponds to the Ireg used in the instruction. For example, clear L2 to disable
circular addressing for register I2. Any nonzero value in an Lreg enables
circular addressing for its corresponding buffer registers.
See the Blackfin Processor Hardware Reference for your specific product for
more details on circular addressing capabilities and operation.

2 PROGRAM FLOW CONTROL
Instruction Summary
• “Jump” on page 2-2
• “IF CC JUMP” on page 2-5
• “Call” on page 2-8
• “RTS, RTI, RTX, RTN, RTE (Return)” on page 2-10
• “LSETUP, LOOP” on page 2-13
Instruction Overview
This chapter discusses the instructions that control program flow. Users
can take advantage of these instructions to force new values into the Pro-
gram Counter and change program flow, branch conditionally, set up
loops, and call and return from subroutines.

Jump
General Form
JUMP (destination_indirect)
JUMP (PC + offset)
JUMP offset
JUMP.S offset
JUMP.L offset
Syntax
JUMP ( Preg ) ; /* indirect to an absolute (not PC-relative)
address (a) */
JUMP ( PC + Preg ) ; /* PC-relative, indexed (a) */
JUMP pcrelm2 ; /* PC-relative, immediate (a) or (b) */
see “Functional Description” on page 2-31
JUMP.S pcrel13m2 ; /* PC-relative, immediate, short (a) */
JUMP.L pcrel25m2 ; /* PC-relative, immediate, long (b) */
JUMP user_label ; /* user-defined absolute address label,
resolved by the assembler/linker to the appropriate PC-relative
instruction (a) or (b) */
Syntax Terminology
Preg: P5–0, SP, FP
pcrelm2: undetermined 25-bit or smaller signed, even relative offset, with

a range of –16,777,216 through 16,777,214 bytes (0xFF00 0000 to
0x00FF FFFE)
pcrel13m2:13-bit signed, even relative offset, with a range of
–4096 through 4094 bytes (0xF000 to 0x0FFE)
1
This instruction can be used in assembly-level programs when the final distance to the target is
unknown at coding time. The assembler substitutes the opcode for JUMP.S or JUMP.L depending on
the final target. Disassembled code shows the mnemonic JUMP.S or JUMP.L.

Program Flow Control
pcrel25m2: 25-bit signed, even relative offset, with a range of

–16,777,216 through 16,777,214 bytes (0xFF00 0000 to 0x00FF FFFE)
user_label: valid assembler address label, resolved by the assembler/linker
to a valid PC-relative offset
Instruction Length
In the syntax, comment (a) identifies 16-bit instruction length. Comment
(b) identifies 32-bit instruction length.
Functional Description
The Jump instruction forces a new value into the Program Counter (PC) to
change program flow.
In the Indirect and Indexed versions of the instruction, the value in Preg
must be an even number (bit0=0) to maintain 16-bit address alignment.
Otherwise, an odd offset in Preg causes the processor to invoke an align-
ment exception.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
The Jump instruction cannot be issued in parallel with other instructions.

Example
jump get_new_sample ; /* assembler resolved target, abstract
offsets */
jump (p5) ; /* P5 contains the absolute address of the target
*/
jump (pc + p2) ; /* P2 relative absolute address of the target
and then a presentation of the absolute values for target */
jump 0x224 ; /* offset is positive in 13 bits, so target
address is PC + 0x224, a forward jump */
jump.s 0x224 ; /* same as above with jump “short” syntax */
jump.l 0xFFFACE86 ; /* offset is negative in 25 bits, so target
address is PC + 0x1FA CE86, a backwards jump */
Also See
Call, IF CC JUMP
Special Applications
None

IF CC JUMP
General Form
IF CC JUMP destination
IF !CC JUMP destination
Syntax
IF CC JUMP pcrel11m2 ; /* branch if CC=1, branch predicted as
not taken (a) */
1
IF CC JUMP pcrel11m2 (bp) ; /* branch if CC=1, branch predicted
as taken (a) */
IF !CC JUMP pcrel11m2 ; /* branch if CC=0, branch predicted as
not taken (a) */
2
IF !CC JUMP pcrel11m2 (bp) ; /* branch if CC=0, branch pre-
dicted as taken (a) */
IF CC JUMP user_label ; /* user-defined absolute address label,
instruction (a) */
IF CC JUMP user_label (bp) ; /* user-defined absolute address
label, resolved by the assembler/linker to the appropriate
PC-relative instruction (a) */
IF !CC JUMP user_label ; /* user-defined absolute address
IF !CC JUMP user_label (bp) ; /* user-defined absolute address
1 CC bit = 1 causes a branch to an address, computed by adding the signed, even offset to the current
PC value.
2 CC bit = 0 causes a branch to an address, computed by adding the signed, even relative offset to the
current PC value.

Syntax Terminology
pcrel11m2: 11-bit signed even relative offset, with a range of –1024
through 1022 bytes (0xFC00 to 0x03FE). This value can optionally be
replaced with an address label that is evaluated and replaced during
linking.
Instruction Length
In the syntax, comment (a) identifies 16-bit instruction length.
The Conditional JUMP instruction forces a new value into the Program
Counter (PC) to change the program flow, based on the value of the CC bit.
The range of valid offset values is –1024 through 1022.
Option
The Branch Prediction appendix (bp) helps the processor improve branch
instruction performance. The default is branch predicted-not-taken. By
appending (bp) to the instruction, the branch becomes predicted-taken.
Typically, code analysis shows that a good default condition is to predict
branch-taken for branches to a prior address (backwards branches), and to
predict branch-not-taken for branches to subsequent addresses (forward
branches).
Flags Affected
None

Required Mode
User & Supervisor
Parallel Issue
This instruction cannot be issued in parallel with other instructions.
Example
if cc jump 0xFFFFFE08 (bp) ; /* offset is negative in 11 bits,
so target address is a backwards branch, branch predicted */
if cc jump 0x0B4 ; /* offset is positive, so target offset
address is a forwards branch, branch not predicted */
if !cc jump 0xFFFFFC22 (bp) ; /* negative offset in 11 bits, so
target address is a backwards branch, branch predicted */
if !cc jump 0x120 ; /* positive offset, so target address is a
forwards branch, branch not predicted */
if cc jump dest_label ; /* assembler resolved target, abstract
offsets */
Also See
Jump, Call
None

Call
General Form
CALL (destination_indirect
CALL (PC + offset)
CALL offset
Syntax
CALL ( Preg ) ; /* indirect to an absolute (not PC-relative)
address (a) */
CALL ( PC + Preg ) ; /* PC-relative, indexed (a) */
CALL pcrel25m2 ; /* PC-relative, immediate (b) */
CALL user_label ; /* user-defined absolute address label,
instruction (a) or (b) */
Syntax Terminology
Preg: P5–0 (SP and FP are not allowed as the source register for this
instruction.)
pcrel25m2: 25-bit signed, even, PC-relative offset; can be specified as a
symbolic address label, with a range of –16,777,216 through 16,777,214
(0xFF00 0000 to 0x00FF FFFE) bytes.
Instruction Length

The CALL instruction calls a subroutine from an address that a P-register
points to or by using a PC-relative offset. After the CALL instruction exe-
cutes, the RETS register contains the address of the next instruction.
The value in the Preg must be an even value to maintain 16-bit alignment.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
call ( p5 ) ;
call ( pc + p2 ) ;
call 0x123456 ;
call get_next_sample ;
Also See
RTS, RTI, RTX, RTN, RTE (Return), Jump, IF CC JUMP
None

RTS, RTI, RTX, RTN, RTE (Return)
General Form
RTS, RTI, RTX, RTN, RTE
Syntax
RTS ; // Return from Subroutine (a)
RTI ; // Return from Interrupt (a)
RTX ; // Return from Exception (a)
RTN ; // Return from NMI (a)
RTE ; // Return from Emulation (a)
Instruction Length
The Return instruction forces a return from a subroutine, maskable or
NMI interrupt routine, exception routine, or emulation routine (see
Table 2-1).
Flags Affected
None
Required Mode
Table 2-2 identifies the modes required by the Return instruction.
Parallel Issue

Table 2-1. Types of Return Instruction

Mnemonic Description
RTS Forces a return from a subroutine by loading the value of the RETS
Register into the Program Counter (PC), causing the processor to fetch
the next instruction from the address contained in RETS. For nested
subroutines, you must save the value of the RETS Register. Otherwise,
the next subroutine CALL instruction overwrites it.
RTI Forces a return from an interrupt routine by loading the value of the
RETI Register into the PC. When an interrupt is generated, the pro-
cessor enters a non-interruptible state. Saving RETI to the stack
re-enables interrupt detection so that subsequent, higher priority inter-
rupts can be serviced (or “nested”) during the current interrupt service
routine. If RETI is not saved to the stack, higher priority interrupts are
recognized but not serviced until the current interrupt service routine
concludes. Restoring RETI back off the stack at the conclusion of the
interrupt service routine masks subsequent interrupts until the RTI
instruction executes. In any case, RETI is protected against inadvertent
corruption by higher priority interrupts.
RTX Forces a return from an exception routine by loading the value of the
RETX Register into the PC.
RTN Forces a return from a non-maskable interrupt (NMI) routine by load-

ing the value of the RETN Register into the PC.
RTE Forces a return from an emulation routine and emulation mode by

loading the value of the RETE Register into the PC. Because only one
emulation routine can run at a time, nesting is not an issue, and saving
the value of the RETE Register is unnecessary.
Table 2-2. Required Mode for the Return Instruction

Mnemonic Required Mode
RTS User & Supervisor
RTI, RTX, and RTN Supervisor only. Any attempt to execute in User mode produces a
protection violation exception.
RTE Emulation only. Any attempt to execute in User mode or Supervi-

sor mode produces an exception.

Example
rts ;
rti ;
rtx ;
rtn ;
rte ;
Also See
Call, --SP (Push), SP++ (Pop)
None

LSETUP, LOOP
General Form
There are two forms of this instruction. The first is:
LOOP loop_name loop_counter
LOOP_BEGIN loop_name
LOOP_END loop_name
The second form is:

LSETUP (Begin_Loop, End_Loop)Loop_Counter
Syntax
For Loop0
LOOP loop_name LC0 ; /* (b) */
LOOP loop_name LC0 = Preg ; /* autoinitialize LC0 (b) */
LOOP loop_name LC0 = Preg >> 1 ; /* autoinit LC0(b) */
LOOP_BEGIN loop_name ; /* define the 1st instruction of loop(b)
*/
LOOP_END loop_name ; /* define the last instruction of the loop
(b) */
/* use any one of the LOOP syntax versions with a LOOP_BEGIN and
a LOOP_END instruction. The name of the loop (“loop_name” in the
syntax) relates the three instructions together. */
LSETUP ( pcrel5m2 , lppcrel11m2 ) LC0 ; /* (b) */

LSETUP ( pcrel5m2 , lppcrel11m2 ) LC0 = Preg ; /* autoinitial-
ize LC0 (b) */
LSETUP ( pcrel5m2 , lppcrel11m2 ) LC0 = Preg >> 1 ; /* autoini-
tialize LC0 (b) */

For Loop1
LOOP loop_name LC1 ; /* (b) */
LOOP loop_name LC1 = Preg ; /* autoinitialize LC1 (b) */
LOOP loop_name LC1 = Preg >> 1 ; /* autoinitialize LC1 (b) */
LOOP_BEGIN loop_name ; /* define the first instruction of the
loop (b) */
LOOP_END loop_name ; /* define the last instruction of the loop
(b) */
/* Use any one of the LOOP syntax versions with a LOOP_BEGIN and
a LOOP_END instruction. The name of the loop (“loop_name” in the
syntax) relates the three instructions together. */
LSETUP ( pcrel5m2 , lppcrel11m2 ) LC1 ; /* (b) */

LSETUP ( pcrel5m2 , lppcrel11m2 ) LC1 = Preg ; /* autoinitial-
ize LC1 (b) */
LSETUP ( pcrel5m2 , lppcrel11m2 ) LC1 = Preg >> 1 ; /* autoini-
tialize LC1 (b) */
Syntax Terminology
Preg: P5–0 (SP and FP are not allowed as the source register for this
instruction.)
pcrel5m2: 5-bit unsigned, even, PC-relative offset; can be replaced by a
symbolic label. The range is 4 to 30, or 25–2.
lppcrel11m2: 11-bit unsigned, even, PC-relative offset for a loop; can be
replaced by a symbolic label. The range is 4 to 2046 (0x0004 to 0x07FE),
or 211–2.
loop_name: a symbolic identifier
Instruction Length
In the syntax, comment (b) identifies 32-bit instruction length.

The Zero-Overhead Loop Setup instruction provides a flexible,
counter-based, hardware loop mechanism that provides efficient,
zero-overhead software loops. In this context, zero-overhead means that
the software in the loops does not incur a performance or code size penalty
by decrementing a counter, evaluating a loop condition, then calculating
and branching to a new target address.
L the
When the address is the next sequential address after
Begin_Loop
instruction, the loop has zero overhead. If the
LSETUP
Begin_Loop address is not the next sequential address after the
LSETUP instruction, there is some overhead that is incurred on loop
entry only.
The architecture includes two sets of three registers each to support two
independent, nestable loops. The registers are Loop_Top (LTn),
Loop_Bottom (LBn) and Loop_Count (LCn). Consequently, LT0, LB0, and
LC0 describe Loop0, and LT1, LB1, and LC1 describe Loop1.
The LOOP and LSETUP instructions are a convenient way to initialize all
three registers in a single instruction. The size of the LOOP and LSETUP
instructions only supports a finite number of bits, so the loop range is lim-
ited. However, LT0 and LT1, LB0 and LB1 and LC0 and LC1 can be
initialized manually using Move instructions if loop length and repetition
count need to be beyond the limits supported by the LOOP and LSETUP syn-
tax. Thus, a single loop can span the entire 4 GB of memory space.
The instruction syntax supports an optional initialization value from a
P-register or P-register divided by 2.
The LOOP, LOOP_BEGIN, LOOP_END syntax is generally more readable and
user friendly. The LSETUP syntax contains the same information, but in a
more compact form.

If LCn is nonzero when the fetch address equals LBn, the processor decre-
ments LCn and places the address in LTn into the PC. The loop always
executes once through because Loop_Count is evaluated at the end of the
loop.
There are two special cases for small loop count values. A value of 0 in
Loop_Count causes the hardware loop mechanism to neither decrement or
loopback, causing the instructions enclosed by the loop pointers to be exe-
cuted as straight-line code. A value of 1 in Loop_Count causes the hardware
loop mechanism to decrement only (not loopback), also causing the
instructions enclosed by the loop pointers to be executed as straight-line
code.
In the instruction syntax, the designation of the loop counter–LC0 or LC1–
determines which loop level is initialized. Consequently, to initialize
Loop0, code LC0; to initialize Loop1, code LC1.
In the case of nested loops that end on the same instruction, the processor
requires Loop0 to describe the outer loop and Loop1 to describe the inner
loop. The user is responsible for meeting this requirement.
For example, if LB0=LB1, then the processor assumes loop 1 is the inner
loop and loop 0 the outer loop.
Just like entries in any other register, loop register entries can be saved and
restored. If nesting beyond two loop levels is required, the user can explic-
itly save the outermost loop register values, re-use the registers for an inner
loop, and then restore the outermost loop values before terminating the
inner loop. In such a case, remember that loop 0 must always be outside of
loop 1. Alternately, the user can implement the outermost loop in soft-
ware with the Conditional Jump structure.
Begin_Loop, the value loaded into LTn, is a 5-bit, PC-relative, even offset
from the current instruction to the first instruction in the loop. The user
is required to preserve half-word alignment by maintaining even values in
this register. The offset is interpreted as a one’s complement, unsigned
number, eliminating backwards loops.

End_Loop, the value loaded into LBn, is an 11-bit, unsigned, even, PC-rela-
tive offset from the current instruction to the last instruction of the loop.
When using the LSETUP instruction, Begin_Loop and End_Loop are typi-
cally address labels. The linker replaces the labels with offset values.
A loop counter register (LC0 or LC1) counts the trips through the loop.
The register contains a 32-bit unsigned value, supporting as many as
4,294,967,294 trips through the loop. The loop is disabled (subsequent
executions of the loop code pass through without reiterating) when the
loop counter equals 0.
There are some restrictions on the last instruction in a loop for
ADSP-BF535 processors. The last instruction of the loop executing on an
ADSP-BF535 Blackfin processor must not be any of the following:
• Jump
• Conditional Branch
• Call
• CSYNC
• SSYNC
• Return (RTS, RTN, etc.)

This last instruction in loop restriction does not apply to other Blackfin
processors.
As long as the hardware loop is active (Loop_Count is nonzero), any of
these forbidden instructions at the End_Loop address produces undefined
execution, and no exception is generated. Forbidden End_Loop instruc-
tions that appear anywhere else in the defined loop execute normally.
Branch instructions that are located anywhere else in the defined loop exe-
cute normally.

Also, the last instruction in the loop must not modify the registers that
define the currently active loop (LCn, LTn, or LBn). User modifications to
those registers while the hardware accesses them produces undefined exe-
cution. Software can legally modify the loop counter at any other location
in the loop.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
lsetup ( 4, 4 ) lc0 ;
lsetup ( poll_bit, end_poll_bit ) lc0 ;
lsetup ( 4, 6 ) lc1 ;
lsetup ( FIR_filter, bottom_of_FIR_filter ) lc1 ;
lsetup ( 4, 8 ) lc0 = p1 ;
lsetup ( 4, 8 ) lc0 = p1>>1 ;
loop DoItSome LC0 ; /* define loop ‘DoItSome’ with Loop Counter

0 */
loop_begin DoItSome ; /* place before the first instruction in
the loop */
loop_end DoItSome ; /* place after the last instruction in the
loop */
loop MyLoop LC1 ; /* define loop ‘MyLoop’ with Loop Counter 1
*/

loop_begin MyLoop ; /* place before the first instruction in

the loop */
loop_end MyLoop ; /* place after the last instruction in the
loop */
Also See
IF CC JUMP, Jump
None


3 LOAD / STORE
Instruction Summary
• “Load Immediate” on page 3-3
• “Load Pointer Register” on page 3-7
• “Load Data Register” on page 3-10
• “Load Half-Word – Zero-Extended” on page 3-15
• “Load Half-Word – Sign-Extended” on page 3-19
• “Load High Data Register Half” on page 3-23
• “Load Low Data Register Half” on page 3-27
• “Load Byte – Zero-Extended” on page 3-31
• “Load Byte – Sign-Extended” on page 3-34
• “Store Pointer Register” on page 3-37
• “Store Data Register” on page 3-40
• “Store High Data Register Half” on page 3-45
• “Store Low Data Register Half” on page 3-49
• “Store Byte” on page 3-54

This chapter discusses the load/store instructions. Users can take advan-
tage of these instructions to load and store immediate values, pointer
registers, data registers or data register halves, and half words (zero or sign
extended).

Load / Store
Load Immediate
General Form
register = constant
A1 = A0 = 0
Syntax
Half-Word Load
reg_lo = uimm16 ; /* 16-bit value into low-half data or
address register (b) */
reg_hi = uimm16 ; /* 16-bit value into high-half data or
Zero Extended
reg = uimm16 (Z) ; /* 16-bit value, zero-extended, into data or
A0 = 0 ; /* Clear A0 register (b) */
A1 = 0 ; /* Clear A1 register (b) */
A1 = A0 = 0 ; /* Clear both A1 and A0 registers (b) */
Sign Extended
Dreg = imm7 (X) ; /* 7-bit value, sign extended, into Dreg (a)
*/
Preg = imm7 (X) ; /* 7-bit value, sign extended, into Preg
(a) */
reg = imm16 (X) ; /* 16-bit value, sign extended, into data or
Syntax Terminology
Dreg: R7–0

reg_lo: R7–0.L, P5–0.L, SP.L, FP.L, I3–0.L, M3–0.L, B3–0.L, L3–0.L
reg_hi: R7–0.H, P5–0.H, SP.H, FP.H, I3–0.H, M3–0.H, B3–0.H, L3–0.H
reg: R7–0, P5–0, SP, FP, I3–0, M3–0, B3–0, L3–0
imm7: 7-bit signed field, with a range of –64 through 63

imm16: 16-bit signed field, with a range of –32,768 through 32,767
(0x800 through 0x7FFF)
uimm16: 16-bit unsigned field, with a range of 0 through 65,535 (0x0000
through 0xFFFF)
Instruction Length
The Load Immediate instruction loads immediate values, or explicit con-
stants, into registers.
The instruction loads a 7-bit or 16-bit quantity, depending on the size of
the immediate data. The range of constants that can be loaded is 0x8000
through 0x7FFF, equivalent to –32768 through +32767.
The only values that can be immediately loaded into 40-bit Accumulator
registers are zeros.
Sixteen-bit half-words can be loaded into either the high half or low half
of a register. The load operation leaves the unspecified half of the register
intact.

Load / Store
Loading a 32-bit value into a register using Load Immediate requires two
separate instructions—one for the high and one for the low half. For
example, to load the address “foo” into register P3, write:
p3.h = foo ;
p3.1 = foo ;
The assembler automatically selects the correct half-word portion of sym-

bolic references for inclusion in the instruction word.
The zero-extended versions fill the upper bits of the destination register
with zeros. The sign-extended versions fill the upper bits with the sign of
the constant value.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
r7 = 63 (z) ;
p3 = 12 (z) ;
r0 = -344 (x) ;
r7 = 436 (z) ;
m2 = 0x89ab (z) ;
p1 = 0x1234 (z) ;
m3 = 0x3456 (x) ;
l3.h = 0xbcde ;
a0 = 0 ;

a1 = 0 ;
a1 = a0 = 0 ;
Also See
Load Pointer Register, Load Pointer Register
Use the Load Immediate instruction to initialize registers.

Load / Store
Load Pointer Register
General Form
P-register = [ indirect_address ]
Syntax
Preg = [ Preg ] ; /* indirect (a) */
Preg = [ Preg ++ ] ; /* indirect, post-increment (a) */
Preg = [ Preg -- ] ; /* indirect, post-decrement (a) */
Preg = [ Preg + uimm6m4 ] ; /* indexed with small offset (a) */
Preg = [ Preg + uimm17m4 ] ; /* indexed with large offset
(b) */
Preg = [ Preg - uimm17m4 ] ; /* indexed with large offset
(b) */
Preg = [ FP - uimm7m4 ] ; /* indexed FP-relative (a) */
Syntax Terminology
uimm6m4: 6-bit unsigned field that must be a multiple of 4, with a range of

0 through 60 bytes
4 through 128 bytes
uimm17m4: 17-bit unsigned field that must be a multiple of 4, with a range
of 0 through 131,068 bytes (0x0000 0000 through 0x0001 FFFC)
Instruction Length

The Load Pointer Register instruction loads a 32-bit P-register with a
32-bit word from an address specified by a P-register.
The indirect address and offset must yield an even multiple of 4 to main-
tain 4-byte word address alignment. Failure to maintain proper alignment
causes a misaligned memory access exception.
Options
The Load Pointer Register instruction supports the following options.
• Post-increment the source pointer by 4 bytes.
• Post-decrement the source pointer by 4 bytes.
• Offset the source pointer with a small (6-bit), word-aligned (multi-
ple of 4), unsigned constant.
• Offset the source pointer with a large (18-bit), word-aligned (mul-
tiple of 4), signed constant.
• Frame Pointer (FP) relative and offset with a 7-bit, word-aligned
(multiple of 4), negative constant.
The indexed FP-relative form is typically used to access local variables in a
subroutine or function. Positive offsets relative to FP (useful to access
arguments from a called function) can be accomplished using one of the
other versions of this instruction. Preg includes the Frame Pointer and
Stack Pointer.
Auto-increment or auto-decrement pointer registers cannot also be the
destination of a Load instruction. For example, sp=[sp++] is not a valid
instruction because it prescribes two competing values for the Stack
Pointer–the data returned from memory, and post-incremented SP++.
Similarly, P0=[P0++] and P1=[P1++], etc. are invalid. Such an instruction
causes an undefined instruction exception.

Load / Store
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
The 16-bit versions of this instruction can be issued in parallel with spe-
cific other instructions. For more information, see “Issuing Parallel
Instructions” on page 15-1.
The 32-bit versions of this instruction cannot be issued in parallel with
other instructions.
Example
p3 = [ p2 ] ;
p5 = [ p0 ++ ] ;
p2 = [ sp -- ] ;
p3 = [ p2 + 8 ] ;
p0 = [ p2 + 0x4008 ] ;
p1 = [ fp - 16 ] ;
Also See
Load Immediate, SP++ (Pop), SP++ (Pop Multiple)
None

Load Data Register
General Form
D-register = [ indirect_address ]
Syntax
Dreg = [ Preg ] ; /* indirect (a) */
Dreg = [ Preg ++ ] ; /* indirect, post-increment (a) */
Dreg = [ Preg -- ] ; /* indirect, post-decrement (a) */
Dreg = [ Preg + uimm6m4 ] ; /* indexed with small offset (a) */
Dreg = [ Preg + uimm17m4 ] ; /* indexed with large offset
(b) */
Dreg = [ Preg - uimm17m4 ] ; /* indexed with large offset
(b) */
Dreg = [ Preg ++ Preg ] ; /* indirect, post-increment index
(a) */
1
Dreg = [ FP - uimm7m4 ] ; /* indexed FP-relative (a) */
Dreg = [ Ireg ] ; /* indirect (a) */
Dreg = [ Ireg ++ ] ; /* indirect, post-increment (a) */
Dreg = [ Ireg -- ] ; /* indirect, post-decrement (a) */
Dreg = [ Ireg ++ Mreg ] ; /* indirect, post-increment index
(a) */
1
Syntax Terminology
Dreg: R7–0
Ireg: I3–0
Mreg: M3–0
1
See “Indirect and Post-Increment Index Addressing” on page 3-12.

Load / Store

0 through 60 bytes
4 through 128 bytes
Instruction Length
The Load Data Register instruction loads a 32-bit word into a 32-bit
D-register from a memory location. The Source Pointer register can be a
P-register, I-register, or the Frame Pointer.
L The instruction versions that explicitly modify support

Ireg
optional circular buffering. See “Automatic Circular Addressing”
on page 1-15 for more details. Unless circular buffering is desired,
disable it prior to issuing this instruction by clearing the Length
Register (Lreg) corresponding to the Ireg used in this instruction.
Example: If you use I2 to increment your address pointer, first
clear L2 to disable circular buffering. Failure to explicitly clear Lreg
beforehand can result in unexpected Ireg values.
The circular address buffer registers (Index, Length, and Base) are
not initialized automatically by Reset. Traditionally, user software
clears all the circular address buffer registers during boot-up to dis-
able circular buffering, then initializes them later, if needed.

Options
The Load Data Register instruction supports the following options.
• Post-increment the source pointer by 4 bytes to maintain word
alignment.
• Post-decrement the source pointer by 4 bytes to maintain word
alignment.
Stack Pointer.
Indirect and Post-Increment Index Addressing

The syntax of the form:
Dest = [ Src_1 ++ Src_2 ]
is indirect, post-increment index addressing. The form is shorthand for

the following sequence.
Dest = [Src_1] ; /* load the 32-bit destination, indirect*/
Src_1 += Src_2 ; /* post-increment Src_1 by a quantity indexed
by Src_2 */

Load / Store
where:
• Dest is the destination register. (Dreg in the syntax example).
• Src_1 is the first source register on the right-hand side of the
equation.
• Src_2 is the second source register.
Indirect and post-increment index addressing supports customized indi-
rect address cadence. The indirect, post-increment index version must
have separate P-registers for the input operands. If a common Preg is used
for the inputs, the auto-increment feature does not work.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
r3 = [ p0 ] ;
r7 = [ p1 ++ ] ;
r2 = [ sp -- ] ;
r6 = [ p2 + 12 ] ;
r0 = [ p4 + 0x800C ] ;

r1 = [ p0 ++ p1 ] ;
r5 = [ fp -12 ] ;
r2 = [ i2 ] ;
r0 = [ i0 ++ ] ;
r0 = [ i0 -- ] ;
/* Before indirect post-increment indexed addressing*/
r7 = 0 ;
i3 = 0x4000 ; /* Memory location contains 15, for example.*/
m0 = 4 ;
r7 = [i3 ++ m0] ;
/* Afterwards . . .*/
/* r7 = 15 from memory location 0x4000*/
/* i3 = i3 + m0 = 0x4004*/
/* m0 still equals 4*/
Also See
Load Immediate
None

Load / Store
Load Half-Word – Zero-Extended
General Form
D-register = W [ indirect_address ] (Z)
Syntax
Dreg = W [ Preg ] (Z) ; /* indirect (a)*/
Dreg = W [ Preg ++ ] (Z) ; /* indirect, post-increment (a)*/
Dreg = W [ Preg -- ] (Z) ; /* indirect, post-decrement (a)*/
Dreg = W [ Preg + uimm5m2 ] (Z) ; /* indexed with small offset
(a) */
Dreg = W [ Preg + uimm16m2 ] (Z) ; /* indexed with large offset
(b) */
Dreg = W [ Preg - uimm16m2 ] (Z) ; /* indexed with large offset
(b) */
Dreg = W [ Preg ++ Preg ] (Z) ; /* indirect, post-increment
index (a) */
1
Syntax Terminology
Dreg: R7–0

0 through 30 bytes
of 0 through 65,534 bytes (0x0000 through 0xFFFC)
1

Instruction Length
The Load Half-Word – Zero-Extended instruction loads 16 bits from a
memory location into the lower half of a 32-bit data register. The instruc-
tion zero-extends the upper half of the register. The Pointer register is a
P-register.
The indirect address and offset must yield an even numbered address to
maintain 2-byte half-word address alignment. Failure to maintain proper
alignment causes a misaligned memory access exception.
Options
The Load Half-Word – Zero-Extended instruction supports the following
options.
• Offset the source pointer with a small (5-bit), half-word-aligned
(even), unsigned constant.
• Offset the source pointer with a large (17-bit), half-word-aligned
(even), signed constant.

Load / Store

Dest = W [ Src_1 ++ Src_2 ]

by Src_2 */
where:
equation.
for the inputs, the instruction functions as a simple, non-incrementing
load. For example, r0 = W[p2++p2](z) functions as r0 = W[p2](z).
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
other instructions.
Example
r3 = w [ p0 ] (z) ;
r7 = w [ p1 ++ ] (z) ;
r2 = w [ sp -- ] (z) ;
r6 = w [ p2 + 12 ] (z) ;
r0 = w [ p4 + 0x8004 ] (z) ;
r1 = w [ p0 ++ p1 ] (z) ;
Also See
Load Half-Word – Sign-Extended, Load Low Data Register Half, Load
High Data Register Half, Load Data Register
To read consecutive, aligned 16-bit values for high-performance DSP
operations, use the Load Data Register instructions instead of these
Half-Word instructions. The Half-Word Load instructions use only half
the available 32-bit data bus bandwidth, possibly imposing a bottleneck
constriction in the data flow rate.

Load / Store
Load Half-Word – Sign-Extended
General Form
D-register = W [ indirect_address ] (X)
Syntax
Dreg = W [ Preg ] (X) ; // indirect (a)
Dreg = W [ Preg ++ ] (X) ; // indirect, post-increment (a)
Dreg = W [ Preg -- ] (X) ; // indirect, post-decrement (a)
Dreg = W [ Preg + uimm5m2 ] (X) ; /* indexed with small offset
(a) */
Dreg = W [ Preg + uimm16m2 ] (X) ; /* indexed with large offset
(b) */
Dreg = W [ Preg - uimm16m2 ] (X) ; /* indexed with large offset
(b) */
Dreg = W [ Preg ++ Preg ] (X) ; /* indirect, post-increment
index (a) */
1
Syntax Terminology
Dreg: R7–0

0 through 30 bytes
of –0 through 65,534 bytes (0x0000 through 0xFFFE)
1

Instruction Length
The Load Half-Word – Sign-Extended instruction loads 16 bits
sign-extended from a memory location into a 32-bit data register. The
Pointer register is a P-register. The MSB of the number loaded is repli-
cated in the whole upper-half word of the destination D-register.
The indirect address and offset must yield an even numbered address to
maintain 2-byte half-word address alignment. Failure to maintain proper
alignment causes a misaligned memory access exception.
Options
The Load Half-Word – Sign-Extended instruction supports the following
options.

Load / Store

Dest = W [ Src_1 ++ Src_2 ] (X)

by Src_2 */
where:
equation.
L Indirect and post-increment index addressing supports customized

indirect address cadence. The indirect, post-increment index ver-
sion must have separate P-registers for the input operands. If a
common Preg is used for the inputs, the instruction functions as a
simple, non-incrementing load. For example, r0 = W[p2++p2]
functions as r0 = W[p2].
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
other instructions.
Example
r3 = w [ p0 ] (x) ;
r7 = w [ p1 ++ ] (x) ;
r2 = w [ sp -- ] (x) ;
r6 = w [ p2 + 12 ] (x) ;
r0 = w [ p4 + 0x800E ] (x) ;
r1 = w [ p0 ++ p1 ] (x) ;
Also See
Load Half-Word – Zero-Extended, Load Low Data Register Half, Load
High Data Register Half

Load / Store
Load High Data Register Half
General Form
Dreg_hi = W [ indirect_address ]
Syntax
Dreg_hi = W [ Ireg ] ; /* indirect (DAG) (a)*/
Dreg_hi = W [ Ireg ++ ] ; /* indirect, post-increment (DAG)
(a) */
Dreg_hi = W [ Ireg -- ] ; /* indirect, post-decrement (DAG)
(a) */
Dreg_hi = W [ Preg ] ; /* indirect (a)*/
Dreg_hi = W [ Preg ++ Preg ] ; /* indirect, post-increment
index (a) */
1
Syntax Terminology
Dreg_hi: R7–0.H
Ireg: I3–0
Instruction Length
The Load High Data Register Half instruction loads 16 bits from a mem-
ory location indicated by an I-register or a P-register into the most
significant half of a 32-bit data register. The operation does not affect the
least significant half.
1

The indirect address must be even to maintain 2-byte half-word address

alignment. Failure to maintain proper alignment causes a misaligned
memory access exception.

Ireg
Options
The Load High Data Register Half instruction supports the following
options.
• Post-increment the source pointer I-register by 2 bytes to maintain
half-word alignment.
• Post-decrement the source pointer I-register by 2 bytes to maintain
half-word alignment.

Load / Store

Dst_hi = [ Src_1 ++ Src_2 ]

Dst_hi = [Src_1] ; /* load the half-word into the upper half of
the destination register, indirect*/
by Src_2 */
where:
• Dst_hi is the most significant half of the destination register.
(Dreg_hi in the syntax example).
• Src_1 is the memory source pointer register on the right-hand side
of the syntax.
• Src_2 is the increment pointer register.
load. For example, r0.h = W[p2++p2] functions as r0.h = W[p2].
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
Example
r3.h = w [ i1 ] ;
r7.h = w [ i3 ++ ] ;
r1.h = w [ i0 -- ] ;
r2.h = w [ p4 ] ;
r5.h = w [ p2 ++ p0 ] ;
Also See
Load Low Data Register Half, Load Half-Word – Zero-Extended, Load
Half-Word – Sign-Extended

Load / Store
Load Low Data Register Half
General Form
Dreg_lo = W [ indirect_address ]
Syntax
Dreg_lo = W [ Ireg ] ; /* indirect (DAG) (a)*/
Dreg_lo = W [ Ireg ++ ] ; /* indirect, post-increment (DAG) (a)
*/
Dreg_lo = W [ Ireg -- ] ; /* indirect, post-decrement (DAG) (a)
*/
Dreg_lo = W [ Preg ] ; /* indirect (a)*/
Dreg_lo = W [ Preg ++ Preg ] ; /* indirect, post-increment
index (a) */
1
Syntax Terminology
Dreg_lo: R7–0.L
Ireg: I3–0
Instruction Length
The Load Low Data Register Half instruction loads 16 bits from a mem-
ory location indicated by an I-register or a P-register into the least
significant half of a 32-bit data register. The operation does not affect the
most significant half of the data register.
1

The indirect address must be even to maintain 2-byte half-word address

alignment. Failure to maintain proper alignment causes an misaligned
memory access exception.

Ireg
Options
The Load Low Data Register Half instruction supports the following
options.
• Post-increment the source pointer I-register by 2 bytes.
• Post-decrement the source pointer I-register by 2 bytes.

Load / Store

Dst_lo = [ Src_1 ++ Src_2 ]

Dst_lo = [Src_1] ; /* load the half-word into the lower half of
the destination register, indirect*/
by Src_2 */
where:
• Dst_lo is the least significant half of the destination register.
(Dreg_lo in the syntax example).
• Src_1 is the memory source pointer register on the right side of the
syntax.
• Src_2 is the increment index register.
load. For example, r0.l = W[p2++p2] functions as r0.l = W[p2].
Flags Affected
None
Required Mode
User & Supervisor

Instruction Length
Parallel Issue
Example
r3.l = w[ i1 ] ;
r7.l = w[ i3 ++ ] ;
r1.l = w[ i0 -- ] ;
r2.l = w[ p4 ] ;
r5.l = w[ p2 ++ p0 ] ;
Also See
Load High Data Register Half, Load Half-Word – Zero-Extended, Load
Half-Word – Sign-Extended
of the available 32-bit data bus bandwidth, possibly imposing a bottleneck

Load / Store
Load Byte – Zero-Extended
General Form
D-register = B [ indirect_address ] (Z)
Syntax
Dreg = B [ Preg ] (Z) ; /* indirect (a)*/
Dreg = B [ Preg ++ ] (Z) ; /* indirect, post-increment (a)*/
Dreg = B [ Preg -- ] (Z) ; /* indirect, post-decrement (a)*/
Dreg = B [ Preg + uimm15 ] (Z) ; /* indexed with offset (b)*/
Dreg = B [ Preg - uimm15 ] (Z) ; /* indexed with offset (b)*/
Syntax Terminology
Dreg: R7–0
uimm15:15-bit unsigned field, with a range of 0 through 32,767 bytes

Instruction Length
The Load Byte – Zero-Extended instruction loads an 8-bit byte,
zero-extended to 32 bits indicated by an I-register or a P-register, from a
memory location into a 32-bit data register. Fill the D-register bits 31–8
with zeros.
The indirect address and offset have no restrictions for memory address
alignment.

Options
The Load Byte – Zero-Extended instruction supports the following
options.
• Post-increment the source pointer by 1 byte.
• Post-decrement the source pointer by 1 byte.
• Offset the source pointer with a 16-bit signed constant.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
r3 = b [ p0 ] (z) ;
r7 = b [ p1 ++ ] (z) ;
r2 = b [ sp -- ] (z) ;
r0 = b [ p4 + 0xFFFF800F ] (z) ;
Also See
Load Byte – Sign-Extended

Load / Store
None

General Form
D-register = B [ indirect_address ] (X)
Syntax
Dreg = B [ Preg ] (X) ; /* indirect (a)*/
Dreg = B [ Preg ++ ] (X) ; /* indirect, post-increment (a)*/
Dreg = B [ Preg -- ] (X) ; /* indirect, post-decrement (a)*/
Dreg = B [ Preg + uimm15 ] (X) ; /* indexed with offset (b)*/
Dreg = B [ Preg - uimm15 ] (X) ; /* indexed with offset (b)*/
Syntax Terminology
Dreg: R7–0

Instruction Length
The Load Byte – Sign-Extended instruction loads an 8-bit byte,
sign-extended to 32 bits, from a memory location indicated by a P-register
into a 32-bit data register. The Pointer register is a P-register. Fill the
D-register bits 31–8 with the most significant bit of the loaded byte.
alignment.

Load / Store
Options
The Load Byte – Sign-Extended instruction supports the following
options.
• Post-increment the source pointer by 1 byte.
• Post-decrement the source pointer by 1 byte.
• Offset the source pointer with a 16-bit signed constant.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
r3 = b [ p0 ] (x) ;
r7 = b [ p1 ++ ](x) ;
r2 = b [ sp -- ] (x) ;
r0 = b [ p4 + 0xFFFF800F ](x) ;
Also See

None

Load / Store
Store Pointer Register
General Form
[ indirect_address ] = P-register
Syntax
[ Preg ] = Preg ; /* indirect (a)*/
[ Preg ++ ] = Preg ; /* indirect, post-increment (a)*/
[ Preg -- ] = Preg ; /* indirect, post-decrement (a)*/
[ Preg + uimm6m4 ] = Preg ; /* indexed with small offset (a)*/
[ Preg + uimm17m4 ] = Preg ; /* indexed with large offset (b)*/
[ Preg - uimm17m4 ] = Preg ; /* indexed with large offset (b)*/
[ FP - uimm7m4 ] = Preg ; /* indexed FP-relative (a)*/
Syntax Terminology

0 through 60 bytes
4 through 128 bytes
Instruction Length

The Store Pointer Register instruction stores the contents of a 32-bit
P-register to a 32-bit memory location. The Pointer register is a P-register.
Options
The Store Pointer Register instruction supports the following options.
• Post-increment the destination pointer by 4 bytes.
• Post-decrement the destination pointer by 4 bytes.
Stack Pointer.
Flags Affected
None

Load / Store
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
[ p2 ] = p3 ;
[ sp ++ ] = p5 ;
[ p0 -- ] = p2 ;
[ p2 + 8 ] = p3 ;
[ p2 + 0x4444 ] = p0 ;
[ fp -12 ] = p1 ;
Also See
--SP (Push), --SP (Push Multiple)
None

Store Data Register
General Form
[ indirect_address ] = D-register
Syntax
Using Pointer Registers
[ Preg ] = Dreg ; /* indirect (a)*/
[ Preg ++ ] = Dreg ; /* indirect, post-increment (a)*/
[ Preg -- ] = Dreg ; /* indirect, post-decrement (a)*/
[ Preg + uimm6m4 ] = Dreg ; /* indexed with small offset (a)*/
[ Preg +
[ uimm17m4 ] = Dreg ; /* indexed with large offset (b)*/
[ Preg - uimm17m4 ] = Dreg ; /* indexed with large offset (b)*/
[ Preg ++ Preg ] = Dreg ; /* indirect, post-increment index (a)
*/
1
[ FP - uimm7m4 ] = Dreg ; /* indexed FP-relative (a)*/
Using Data Address Generator (DAG) Registers

[ Ireg ] = Dreg ; /* indirect (a)*/
[ Ireg ++ ] = Dreg ; /* indirect, post-increment (a)*/
[ Ireg -- ] = Dreg ; /* indirect, post-decrement (a)*/
[ Ireg ++ Mreg ] = Dreg ; /* indirect, post-increment index (a)
*/
Syntax Terminology
Dreg: R7–0
1

Load / Store
Ireg: I3–0
Mreg: M3–0

0 through 60 bytes
4 through 128 bytes
of 0 through 131,068 bytes (0x0000 through 0xFFFC)
Instruction Length
The Store Data Register instruction stores the contents of a 32-bit D-reg-
ister to a 32-bit memory location. The destination Pointer register can be
a P-register, I-register, or the Frame Pointer.

Ireg


Options
The Store Data Register instruction supports the following options.
subroutine or function. Positive offsets relative to FP (such as is useful to
access arguments from a called function) can be accomplished using one
of the other versions of this instruction. Preg includes the Frame Pointer
and Stack Pointer.

Load / Store

[Dst_1 ++ Dst_2] = Src

[Dst_1] = Src ; /* load the 32-bit source, indirect*/
Dst_1 += Dst_2 ; /* post-increment Dst_1 by a quantity indexed
by Dst_2 */
where:
• Src is the source register. (Dreg in the syntax example).
• Dst_1 is the memory destination register on the left side of the
equation.
• Dst_2 is the increment index register.
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
other instructions.
Example
[ p0 ] = r3 ;
[ p1 ++ ] = r7 ;
[ sp -- ] = r2 ;
[ p2 + 12 ] = r6 ;
[ p4 - 0x1004 ] = r0 ;
[ p0 ++ p1 ] = r1 ;
[ fp - 28 ] = r5 ;
[ i2 ] = r2 ;
[ i0 ++ ] = r0 ;
[ i0 -- ] = r0 ;
[ i3 ++ m0 ] = r7 ;
Also See
Load Immediate
None

Load / Store
Store High Data Register Half
General Form
W [ indirect_address ] = Dreg_hi
Syntax
W [ Ireg ] = Dreg_hi ; /* indirect (DAG) (a)*/
W [ Ireg ++ ] = Dreg_hi ; /* indirect, post-increment (DAG) (a)
*/
W [ Ireg -- ] = Dreg_hi ; /* indirect, post-decrement (DAG) (a)
*/
W [ Preg ] = Dreg_hi ; /* indirect (a)*/
W [ Preg ++ Preg ] = Dreg_hi ; /* indirect, post-increment
index (a) */
1
Syntax Terminology
Dreg_hi: P7–0.H
Ireg: I3–0
Instruction Length
The Store High Data Register Half instruction stores the most significant
16 bits of a 32-bit data register to a 16-bit memory location. The Pointer
register is either an I-register or a P-register.
1

The indirect address and offset must yield an even number to maintain
2-byte half-word address alignment. Failure to maintain proper alignment

Ireg
Options
The Store High Data Register Half instruction supports the following
options.
• Post-increment the destination pointer I-register by 2 bytes.
• Post-decrement the destination pointer I-register by 2 bytes.

Load / Store

[Dst_1 ++ Dst_2] = Src_hi

[Dst_1] = Src_hi ; /* store the upper half of the source regis-
ter, indirect*/
by Dst_2 */
where:
• Src_hi is the most significant half of the source register. (Dreg_hi
in the syntax example).
• Dst_1 is the memory destination pointer register on the left side of
the syntax.
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
Example
w[ i1 ] = r3.h ;
w[ i3 ++ ] = r7.h ;
w[ i0 -- ] = r1.h ;
w[ p4 ] = r2.h ;
w[ p2 ++ p0 ] = r5.h ;
Also See
Store Low Data Register Half
To write consecutive, aligned 16-bit values for high-performance DSP
operations, use the Store Data Register instructions instead of these
Half-Word instructions. The Half-Word Store instructions use only half

Load / Store
General Form
W [ indirect_address ] = Dreg_lo
W [ indirect_address ] = D-register
Syntax
W [ Ireg ] = Dreg_lo ; /* indirect (DAG) (a)*/
W [ Ireg ++ ] = Dreg_lo ; /* indirect, post-increment (DAG) (a)
*/
W [ Ireg -- ] = Dreg_lo ; /* indirect, post-decrement (DAG) (a)
*/
W [ Preg ] = Dreg_lo ; /* indirect (a)*/
W [ Preg ] = Dreg ; /* indirect (a)*/
W [ Preg ++ ] = Dreg ; /* indirect, post-increment (a)*/
W [ Preg -- ] = Dreg ; /* indirect, post-decrement (a)*/
W [ Preg + uimm5m2 ] = Dreg ; /* indexed with small offset (a)
*/
W [ Preg + uimm16m2 ] = Dreg ; /* indexed with large offset (b)
*/
W [ Preg - uimm16m2 ] = Dreg ; /* indexed with large offset (b)
*/
W [ Preg ++ Preg ] = Dreg_lo ; /* indirect, post-increment
index (a) */
1
Syntax Terminology
Dreg_lo: R7–0.L
Ireg: I3–0
1

Dreg: R7–0

0 through 30 bytes
of 0 through 65,534 bytes (0x0000 through 0xFFFE)
Instruction Length
The Store Low Data Register Half instruction stores the least significant
16 bits of a 32-bit data register to a 16-bit memory location. The Pointer
register is either an I-register or a P-register.
The indirect address and offset must yield an even number to maintain
2-byte half-word address alignment. Failure to maintain proper alignment
causes an misaligned memory access exception.

Ireg

Load / Store
Options
The Store Low Data Register Half instruction supports the following
options.

[Dst_1 ++ Dst_2] = Src

[Dst_1] = Src_lo ; /* store the lower half of the source regis-
ter, indirect*/
by Dst_2 */
where:
• Src is the least significant half of the source register. (Dreg or
Dreg_lo in the syntax example).
• Dst_1 is the memory destination pointer register on the left side of
the syntax.


Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
w [ i1 ] = r3.l ;
w [ p0 ] = r3 ;
w [ i3 ++ ] = r7.l ;
w [ i0 -- ] = r1.l ;
w [ p4 ] = r2.l ;
w [ p1 ++ ] = r7 ;
w [ sp -- ] = r2 ;
w [ p2 + 12 ] = r6 ;
w [ p4 - 0x200C ] = r0 ;
w [ p2 ++ p0 ] = r5.l ;

Load / Store
Also See
Store High Data Register Half, Store Data Register
To write consecutive, aligned 16-bit values for high-performance DSP
operations, use the Store Data Register instructions instead of these
Half-Word instructions. The Half-Word Store instructions use only half

Store Byte
General Form
B [ indirect_address ] = D-register
Syntax
B [ Preg ] = Dreg ; /* indirect (a)*/
B [ Preg ++ ] = Dreg ; /* indirect, post-increment (a)*/
B [ Preg -- ] = Dreg ; /* indirect, post-decrement (a)*/
B [ Preg + uimm15 ] = Dreg ; /* indexed with offset (b)*/
B [ Preg - uimm15 ] = Dreg ; /* indexed with offset (b)*/
Syntax Terminology
Dreg: R7–0

Instruction Length
The Store Byte instruction stores the least significant 8-bit byte of a data
register to an 8-bit memory location. The Pointer register is a P-register.
alignment.

Load / Store
Options
The Store Byte instruction supports the following options.
• Post-increment the destination pointer by 1 byte to maintain byte
alignment.
• Post-decrement the destination pointer by 1 byte to maintain byte
alignment.
• Offset the destination pointer with a 16-bit signed constant.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
b [ p0 ] = r3 ;
b [ p1 ++ ] = r7 ;
b [ sp -- ] = r2 ;
b [ p4 + 0x100F ] = r0 ;
b [ p4 - 0x53F ] = r0 ;

Also See
None
To write consecutive, 8-bit values for high-performance DSP operations,
use the Store Data Register instructions instead of these byte instructions.
The byte store instructions use only one fourth the available 32-bit data
bus bandwidth, possibly imposing a bottleneck constriction in the data
flow rate.

4 MOVE
Instruction Summary
• “Move Register” on page 4-2
• “Move Conditional” on page 4-8
• “Move Half to Full Word – Zero-Extended” on page 4-10
• “Move Half to Full Word – Sign-Extended” on page 4-13
• “Move Register Half” on page 4-15
• “Move Byte – Zero-Extended” on page 4-23
• “Move Byte – Sign-Extended” on page 4-25
This chapter discusses the move instructions. Users can take advantage of
these instructions to move registers (or register halves), move half words
(zero or sign extended), move bytes, and perform conditional moves.

Move Register
General Form
dest_reg = src_reg
Syntax
genreg = genreg ; /* (a) */
genreg = dagreg ; /* (a) */
dagreg = genreg ; /* (a) */
dagreg = dagreg ; /* (a) */
genreg = USP ; /* (a)*/
USP = genreg ; /* (a)*/
Dreg = sysreg ; /* sysreg to 32-bit D-register (a) */
sysreg = Dreg ; /* 32-bit D-register to sysreg (a) */
sysreg = Preg ; /* 32-bit P-register to sysreg (a) */
sysreg = USP ; /* (a) */
A0 = A1 ; /* move 40-bit Accumulator value (b) */
A1 = A0 ; /* move 40-bit Accumulator value (b) */
A0 = Dreg ; /* 32-bit D-register to 40-bit A0, sign extended
(b)*/
A1 = Dreg ; /* 32-bit D-register to 40-bit A1, sign extended
(b)*/
Accumulator to D-register Move:

Dreg_even = A0 (opt_mode) ; /* move 32-bit A0.W to even Dreg
(b) */
Dreg_odd = A1 (opt_mode) ; /* move 32-bit A1.W to odd Dreg (b)
*/
Dreg_even = A0, Dreg_odd = A1 (opt_mode) ; /* move both Accumu-
lators to a register pair (b) */
Dreg_odd = A1, Dreg_even = A0 (opt_mode) ; /* move both Accumu-
lators to a register pair (b) */

Move
Syntax Terminology
genreg: R7–0, P5–0, SP, FP, A0.X, A0.W, A1.X, A1.W
dagreg: I3–0, M3–0, B3–0, L3–0
sysreg: ASTAT, SEQSTAT, SYSCFG, RETI, RETX, RETN, RETE, RETS, LC0 and
LC1, LT0 and LT1, LB0 and LB1, CYCLES, CYCLES2, and EMUDAT
USP: The User Stack Pointer Register
Dreg: R7–0
Dreg_even: R0, R2, R4, R6
Dreg_odd: R1, R3, R5, R7
L When combining
and
Dreg_even
two moves in the same instruction, the
operands must be members of the same
Dreg_odd
register pair, e.g. from the set R1:0, R3:2, R5:4, R7:6.
opt_mode: Optionally (FU) or (ISS2)
Instruction Length
The Move Register instruction copies the contents of the source register
into the destination register. The operation does not affect the source reg-
ister contents.
All moves from smaller to larger registers are sign extended.

All moves from 40-bit Accumulators to 32-bit D-registers support

saturation.
Options
The Accumulator to Data Register Move instruction supports the options
listed in the table below.
Table 4-1. Accumulator to Data Register Move

Option Accumulator Copy Formatting
Default Signed fraction. Copy Accumulator 9.31 format to register 1.31 format. Saturate
results between minimum -1 and maximum 1-2-31.
Signed integer. Copy Accumulator 40.0 format to register 32.0 format. Saturate
results between minimum -231 and maximum 231-1.
In either case, the resulting hexadecimal range is minimum 0x8000 0000 through
maximum 0x7FFF FFFF.
The Accumulator is unaffected by extraction.
(FU) Unsigned fraction. Copy Accumulator 8.32 format to register 0.32 format. Saturate
results between minimum 0 and maximum 1-2-32.
Unsigned integer. Copy Accumulator 40.0 format to register 32.0 format. Saturate
results between minimum 0 and maximum 232-1.
maximum 0xFFFF FFFF.
(ISS2) Signed fraction with scaling. Shift the Accumulator contents one place to the left
(multiply x 2). Saturate result to 1.31 format. Copy to destination register. Results
range between minimum -1 and maximum 1-2-31.
Signed integer with scaling. Shift the Accumulator contents one place to the left
(multiply x 2). Saturate result to 32.0 format. Copy to destination register. Results
range between minimum -1 and maximum 231-1.
maximum 0x7FFF FFFF.
See “Saturation” on page 1-11 for a description of saturation behavior.

Move
Flags Affected
The ASTAT register that contains the flags can be explicitly modified by
this instruction.
The Accumulator to D-register Move versions of this instruction affect the
following flags.
• V is set if the result written to the D-register file saturates 32 bits;
cleared if no saturation. In the case of two simultaneous operations,
V represents the logical “OR” of the two.
• VS is set if V is set; unaffected otherwise.

• AZ is set if result is zero; cleared if nonzero. In the case of two
simultaneous operations, AZ represents the logical “OR” of the two.
• ANis set if result is negative; cleared if non-negative. In the case of
two simultaneous operations, AN represents the logical “OR” of the
two.
• All other flags are unaffected.

ASTAT
on page A-2.
Required Mode
User & Supervisor for most cases.
Explicit accesses to USP, SEQSTAT, SYSCFG, RETI, RETX, RETN and RETE
require Supervisor mode. If any of these registers are explicitly accessed
from User mode, an Illegal Use of Protected Resource exception occurs.

Parallel Issue
cific other 16-bit instructions. For more information, see “Issuing Parallel
other instructions.
Example
r3 = r0 ;
r7 = p2 ;
r2 = a0 ;
a0 = a1 ;
a1 = a0 ;
a0 = r7 ; /* move R7 to 32-bit A0.W */
a1 = r3 ; /* move R3 to 32-bit A1.W */
retn = p0 ; /* must be in Supervisor mode */
r2 = a0 ; /* 32-bit move with saturation */
r7 = a1 ; /* 32-bit move with saturation */
r0 = a0 (iss2) ; /* 32-bit move with scaling, truncation and
saturation */
Also See
Load Immediate to initialize registers.
Move Register Half to move values explicitly into the A0.X and A1.X
registers.
LSETUP, LOOP to implicitly access registers LC0, LT0, LB0, LC1, LT1 and
LB1.
Call, RAISE (Force Interrupt / Reset) and RTS, RTI, RTX, RTN, RTE
(Return) to implicitly access registers RETI, RETN, and RETS.

Move
Force Exception and Force Emulation to implicitly access registers RETX

and RETE.
None

Move Conditional
General Form
IF CC dest_reg = src_reg
IF ! CC dest_reg = src_reg
Syntax
IF CC DPreg = DPreg ; /* move if CC = 1 (a) */
IF ! CC DPreg = DPreg ; /* move if CC = 0 (a) */
Syntax Terminology
DPreg: R7–0, P5–0, SP, FP
Instruction Length
The Move Conditional instruction moves source register contents into a
destination register, depending on the value of CC.
IF CC DPreg = DPreg, the move occurs only if CC = 1.
IF ! CC DPreg = DPreg, the move occurs only if CC = 0.
The source and destination registers are any D-register or P-register.
Flags Affected
None
Required Mode
User & Supervisor

Move
Parallel Issue
The Move Conditional instruction cannot be issued in parallel with other
instructions.
Example
if cc r3 = r0 ; /* move if CC=1 */
if cc r2 = p4 ;
if cc p0 = r7 ;
if cc p2 = p5 ;
if ! cc r3 = r0 ; /* move if CC=0 */
if ! cc r2 = p4 ;
if ! cc p0 = r7 ;
if ! cc p2 = p5 ;
Also See
Compare Accumulator, Move CC, Negate CC, IF CC JUMP
None

Move Half to Full Word – Zero-Extended
General Form
dest_reg = src_reg (Z)
Syntax
Dreg = Dreg_lo (Z) ; /* (a) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Instruction Length
The Move Half to Full Word – Zero-Extended instruction converts an
unsigned half word (16 bits) to an unsigned word (32 bits).
The instruction copies the least significant 16 bits from a source register
into the lower half of a 32-bit register and zero-extends the upper half of
the destination register. The operation supports only D-registers. Zero
extension is appropriate for unsigned values. If used with signed values, a
small negative 16-bit value will become a large positive value.

Move
Flags Affected
The following flags are affected by the Move Half to Full Word –
Zero-Extended instruction.
• AZ is set if result is zero; cleared if nonzero.
• AN is cleared.
• AC0 is cleared.
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
/* If r0.l = 0xFFFF */
r4 = r0.l (z) ; /* Equivalent to r4.l = r0.l and r4.h = 0 */
/* . . . then r4 = 0x0000FFFF */
Also See
Move Half to Full Word – Sign-Extended, Move Register Half

None

Move
Move Half to Full Word – Sign-Extended
General Form
dest_reg = src_reg (X)
Syntax
Dreg = Dreg_lo (X) ; /* (a)*/
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Instruction Length
The Move Half to Full Word – Sign-Extended instruction converts a
signed half word (16 bits) to a signed word (32 bits). The instruction cop-
ies the least significant 16 bits from a source register into the lower half of
a 32-bit register and sign-extends the upper half of the destination regis-
ter. The operation supports only D-registers.
Flags Affected
The following flags are affected by the Move Half to Full Word –
Sign-Extended instruction.
• AN is set if result is negative; cleared if non-negative.
• AC0 is cleared.

• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
This instruction cannot be issued in parallel with any other instructions.
Example
r4 = r0.l(x) ;
r4 = r0.l ;
Also See
Move Half to Full Word – Zero-Extended, Move Register Half
None

Move
Move Register Half
General Form
dest_reg_half = src_reg_half
dest_reg_half = accumulator (opt_mode)
Syntax
A0.X = Dreg_lo ; /* least significant 8 bits of Dreg into A0.X
1
(b) */
A1.X = Dreg_lo ; /* least significant 8 bits of Dreg into A1.X
(b) */
Dreg_lo = A0.X ; /* 8-bit A0.X, sign-extended, into least sig-
nificant 16 bits of Dreg (b) */
Dreg_lo = A1.X ; /* 8-bit A1.X, sign-extended, into least sig-
nificant 16 bits of Dreg (b) */
A0.L = Dreg_lo ; /* least significant 16 bits of Dreg into
least significant 16 bits of A0.W (b) */
A1.L = Dreg_lo ; /* least significant 16 bits of Dreg into
least significant 16 bits of A1.W (b) */
A0.H = Dreg_hi ; /* most significant 16 bits of Dreg into most
significant 16 bits of A0.W (b) */
A1.H = Dreg_hi ; /* most significant 16 bits of Dreg into most
significant 16 bits of A1.W (b) */
1
The Accumulator Extension registers A0.X and A1.X are defined only for the 8 low-order bits 7
through 0 of A0.X and A1.X. This instruction truncates the upper byte of Dreg_lo before moving the
value into the Accumulator Extension register (A0.X or A1.X).

Accumulator to Half D-register Moves

Dreg_lo = A0 (opt_mode) ; /* move A0 to lower half of Dreg (b) */
Dreg_hi = A1 (opt_mode) ; /* move A1 to upper half of Dreg (b)
*/
Dreg_lo = A0, Dreg_hi = A1 (opt_mode) ; /* move both values at
once; must go to the lower and upper halves of the same Dreg (b)
*/
Dreg_hi = A1, Dreg_lo = AO (opt_mode) ; /* move both values at
once; must go to the upper and lower halves of the same Dreg (b)
*/
Syntax Terminology
Dreg_lo: R7–0.L
Dreg_hi: R7–0.H
A0.L: the least significant 16 bits of Accumulator A0.W

A1.L: the least significant 16 bits of Accumulator A1.W
A0.H: the most significant 16 bits of Accumulator A0.W
A1.H: the most significant 16 bits of Accumulator A1.W
opt_mode: Optionally (FU), (IS), (IU), (T), (S2RND), (ISS2), or (IH)
Instruction Length

Move
The Move Register Half instruction copies 16 bits from a source register
into half of a 32-bit register. The instruction does not affect the unspeci-
fied half of the destination register. It supports only D-registers and the
Accumulator.
One version of the instruction simply copies the 16 bits (saturated at 16
bits) of the Accumulator into a data half-register. This syntax supports
truncation and rounding beyond a simple Move Register Half instruction.
The fraction version of this instruction (the default option) transfers the
Accumulator result to the destination register according to the diagrams in
Figure 4-1. Accumulator A0.H contents transfer to the lower half of the
destination D-register. A1.H contents transfer to the upper half of the des-
tination D-register.
A0.X A0.H A0.L
A0 0000 0000 XXXX XXXX XXXX XXXXXXXX XXXX XXXX XXXX
Destination Register XXXX XXXX XXXX XXXXXXXX XXXX XXXX XXXX
A0.X A0.H A0.L
Figure 4-1. Result to Destination Register (Default Option)

The integer version of this instruction (the (IS) option) transfers the
Accumulator result to the destination register according to the diagrams,
shown in Figure 4-2. Accumulator A0.L contents transfer to the lower half
of the destination D-register. A1.L contents transfer to the upper half of
the destination D-register.
A0.X A0.H A0.L
A0.X A0.H A0.L
Figure 4-2. Result to Destination Register ((IS) Option)
Some versions of this instruction are affected by the RND_MOD bit in the
ASTAT register when they copy the results into the destination register.
RND_MOD determines whether biased or unbiased rounding is used. RND_MOD
controls rounding for all versions of this instruction except the (IS) and
(ISS2) options.
See “Rounding and Truncating” on page 1-13 for a description of round-

ing behavior.

Move
Options
The Accumulator to Half D-Register Move instructions support the copy
options in Table 4-2.
Table 4-2. Accumulator to Half D-Register Move Options

Default Signed fraction format. Round Accumulator 9.31 format value at bit 16.
(RND_MOD bit in the ASTAT register controls the rounding.) Saturate the
result to 1.15 precision and copy it to the destination register half. Result is
between minimum -1 and maximum 1-2-15 (or, expressed in hex, between mini-
mum 0x8000 and maximum 0x7FFF).
(FU) Unsigned fraction format. Round Accumulator 8.32 format value at bit 16.
between minimum 0 and maximum 1-2-16 (or, expressed in hex, between mini-
mum 0x0000 and maximum 0xFFFF).
(IS) Signed integer format. Extract the lower 16 bits of the Accumulator. Saturate for
16.0 precision and copy to the destination register half. Result is between mini-
mum -215 and maximum 215-1 (or, expressed in hex, between minimum 0x8000
and maximum 0x7FFF).
(IU) Unsigned integer format. Extract the lower 16 bits of the Accumulator. Saturate
for 16.0 precision and copy to the destination register half. Result is between
minimum 0 and maximum 216-1 (or, expressed in hex, between minimum
0x0000 and maximum 0xFFFF).
(T) Signed fraction with truncation. Truncate Accumulator 9.31 format value at bit
16. (Perform no rounding.) Saturate the result to 1.15 precision and copy it to
the destination register half. Result is between minimum -1 and maximum
1-2-15 (or, expressed in hex, between minimum 0x8000 and maximum 0x7FFF).

Table 4-2. Accumulator to Half D-Register Move Options (Cont’d)

(S2RND) Signed fraction with scaling and rounding. Shift the Accumulator contents one
place to the left (multiply x 2). Round Accumulator 9.31 format value at bit 16.
mum 0x8000 and maximum 0x7FFF).
(ISS2) Signed integer with scaling. Extract the lower 16 bits of the Accumulator. Shift
them one place to the left (multiply x 2). Saturate the result for 16.0 format and
copy to the destination register half. Result is between minimum -215 and maxi-
mum 215-1 (or, expressed in hex, between minimum 0x8000 and maximum
0x7FFF).
(IH) Signed integer, high word extract. Round Accumulator 40.0 format value at bit
16. (RND_MOD bit in the ASTAT register controls the rounding.) Saturate to
32.0 result. Copy the upper 16 bits of that value to the destination register half.
Result is between minimum -215 and maximum 215-1 (or, expressed in hex,
between minimum 0x8000 and maximum 0x7FFF).
To truncate the result, the operation eliminates the least significant bits
that do not fit into the destination register.
When necessary, saturation is performed after the rounding.
Flags Affected
The Accumulator to Half D-register Move versions of this instruction
affect the following flags.
• V is set if the result written to the half D-register file saturates 16
bits; cleared if no saturation.

Move

Flags are not affected by other versions of this instruction.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
cific other 16-bit instructions. For more information, see “Issuing Parallel
Example
a0.x = r1.l ;
a1.x = r4.l ;
r7.l = a0.x ;
r0.l = a1.x ;
a0.l = r2.l ;
a1.l = r1.l ;
a0.l = r5.l ;
a1.l = r3.l ;
a0.h = r7.h ;
a1.h = r0.h ;
r7.l = a0 ; /* copy A0.H into R7.L with saturation. */
r2.h = a1 ; /* copy A0.H into R2.H with saturation. */

r3.1 = a0, r3.h = a1 ; /* copy both half words; must go to the

lower and upper halves of the same Dreg. */
r1.h = a1, rl.l = a0 ; /* copy both half words; must go to the
upper and lower halves of the same Dreg.
r0.h = a1 (is) ; /* copy A1.L into R0.H with saturation. */
r5.l = a0 (t) ; /* copy A0.H into R5.L; truncate A0.L; no satu-
ration. */
r1.l = a0 (s2rnd) ; /* copy A0.H into R1.L with scaling, round-
ing & saturation. */
r2.h = a1 (iss2) ; /* copy A1.L into R2.H with scaling and sat-
uration. */
r6.l = a0 (ih) ; /* copy A0.H into R6.L with saturation, then
rounding. */
Also See
Move Half to Full Word – Zero-Extended, Move Half to Full Word –
Sign-Extended
None

Move
Move Byte – Zero-Extended
General Form
dest_reg = src_reg_byte (Z)
Syntax
Dreg = Dreg_byte (Z) ; /* (a)*/
Syntax Terminology
Dreg_byte: R7–0.B, the low-order 8 bits of each Data Register
Instruction Length
The Move Byte – Zero-Extended instruction converts an unsigned byte to
an unsigned word (32 bits). The instruction copies the least significant 8
bits from a source register into the least significant 8 bits of a 32-bit regis-
ter. The instruction zero-extends the upper bits of the destination register.
This instruction supports only D-registers.
Flags Affected
The following flags are affected by the Move Byte – Zero-Extended
instruction.
• AN is cleared.
• AC0 is cleared.

• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r7 = r2.b (z) ;
Also See
Move Register Half to explicitly access the Accumulator Extension regis-
ters A0.X and A1.X.
Move Byte – Sign-Extended
None

Move
Move Byte – Sign-Extended
General Form
dest_reg = src_reg_byte (X)
Syntax
Dreg = Dreg_byte (X) ; /* (a) */
Syntax Terminology
Dreg_byte: R7–0.B, the low-order 8 bits of each Data Register
Instruction Length
The Move Byte – Sign-Extended instruction converts a signed byte to a
signed word (32 bits). It copies the least significant 8 bits from a source
register into the least significant 8 bits of a 32-bit register. The instruction
sign-extends the upper bits of the destination register. This instruction
supports only D-registers.
Flags Affected
The following flags are affected by the Move Byte – Sign-Extended
instruction.
• AC0 is cleared.

• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r7 = r2.b ;
r7 = r2.b(x) ;
Also See
Move Byte – Zero-Extended
None

5 STACK CONTROL
Instruction Summary
• “--SP (Push)” on page 5-2
• “--SP (Push Multiple)” on page 5-5
• “SP++ (Pop)” on page 5-8
• “SP++ (Pop Multiple)” on page 5-12
• “LINK, UNLINK” on page 5-17
This chapter discusses the instructions that control the stack. Users can
take advantage of these instructions to save the contents of single or multi-
ple registers to the stack or to control the stack frame space on the stack
and the Frame Pointer (FP) for that space.

--SP (Push)
General Form
[ -- SP ] = src_reg
Syntax
[ -- SP ] = allreg ; /* predecrement SP (a) */
Syntax Terminology
allreg: R7–0, P5–0, FP, I3–0, M3–0, B3–0, L3–0, A0.X, A0.W, A1.X, A1.W,
ASTAT, RETS, RETI, RETX, RETN, RETE, LC0, LC1, LT0, LT1, LB0, LB1, CYCLES,
CYCLES2, EMUDAT, USP, SEQSTAT, and SYSCFG
Instruction Length
The Push instruction stores the contents of a specified register in the
stack. The instruction pre-decrements the Stack Pointer to the next avail-
able location in the stack first. Push and Push Multiple are the only
instructions that perform pre-modify functions.
The stack grows down from high memory to low memory. Consequently,
the decrement operation is used for pushing, and the increment operation
is used for popping values. The Stack Pointer always points to the last
used location. Therefore, the effective address of the push is SP–4.
The following illustration shows what the stack would look like when a
series of pushes occur.

Stack Control
higher memory
P5 [--sp]=p5 ;
P1 [--sp]=p1 ;
R3 <-------- SP [--sp]=r3 ;
...
lower memory
The Stack Pointer must already be 32-bit aligned to use this instruction. If
an unaligned memory access occurs, an exception is generated and the
instruction aborts.
Push/pop on RETS has no effect on the interrupt system.
Push/pop on RETI does affect the interrupt system.
Pushing RETI enables the interrupt system, whereas popping RETI disables
the interrupt system.
Pushing the Stack Pointer is meaningless since it cannot be retrieved from
the stack. Using the Stack Pointer as the destination of a pop instruction
(as in the fictional instruction SP=[SP++]) causes an undefined instruction
exception. (Refer to “Register Names” on page 1-6 for more information.)
Flags Affected
None
Required Mode
User & Supervisor for most cases.
Explicit accesses to USP, SEQSTAT, SYSCFG, RETI, RETX, RETN, and RETE
requires Supervisor mode. A protection violation exception results if any
of these registers are explicitly accessed from User mode.

Parallel Issue
Example
[ -- sp ] = r0 ;
[ -- sp ] = r1 ;
[ -- sp ] = p0 ;
[ -- sp ] = i0 ;
Also See
--SP (Push Multiple), SP++ (Pop)
None

Stack Control
--SP (Push Multiple)
General Form
[ -- SP ] = (src_reg_range)
Syntax
[ -- SP ] = ( R7 : Dreglim , P5 : Preglim ) ; /* Dregs and
indexed Pregs (a) */
[ -- SP ] = ( R7 : Dreglim ) ; /* Dregs, only (a) */
[ -- SP ] = ( P5 : Preglim ) ; /* indexed Pregs, only (a) */
Syntax Terminology
Dreglim: any number in the range 7 through 0
Preglim: any number in the range 5 through 0
Instruction Length
The Push Multiple instruction saves the contents of multiple data and/or
Pointer registers to the stack. The range of registers to be saved always
includes the highest index register (R7 and/or P5) plus any contiguous
lower index registers specified by the user down to and including R0
and/or P0. Push and Push Multiple are the only instructions that perform
pre-modify functions.
The instructions start by saving the register having the lowest index then
advance to the register with the highest index. The index of the first regis-
ter saved in the stack is specified by the user in the instruction syntax.
Data registers are pushed before Pointer registers if both are specified in
one instruction.

The instruction pre-decrements the Stack Pointer to the next available

location in the stack first.
The stack grows down from high memory to low memory, therefore the
decrement operation is the same used for pushing, and the increment
operation is used for popping values. The Stack Pointer always points to
the last used location. Therefore, the effective address of the push is SP–4.
The following illustration shows what the stack would look like when a
push multiple occurs.
higher memory
P3 [--sp]=(p5:3) ;
P4
P5 <-------- SP
...
lower memory
Because the lowest-indexed registers are saved first, it is advisable that a
runtime system be defined to have its compiler scratch registers as the low-
est-indexed registers. For instance, data registers R0, P0 would be the
return value registers for a simple calling convention.
Although this instruction takes a variable amount of time to complete
depending on the number of registers to be saved, it reduces compiled
code size.
This instruction is not interruptible. Interrupts asserted after the first
issued stack write operation are appended until all the writes complete.
However, exceptions that occur while this instruction is executing cause it
to abort gracefully. For example, a load/store operation might cause a pro-
tection violation while Push Multiple is executing. The SP is reset to its
value before the execution of this instruction. This measure ensures that

Stack Control
the instruction can be restarted after the exception. Note that when a Push
Multiple operation is aborted due to an exception, the memory state is
changed by the stores that have already completed before the exception.
instruction aborts, as described above.
Only pointer registers P5–0 can be operands for this instruction; SP and FP
cannot. All data registers R7–0 can be operands for this instruction.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
[ -- sp ] = (r7:5, p5:0) ; /* D-registers R4:0 excluded */
[ -- sp ] = (r7:2) ; /* R1:0 excluded */
[ -- sp ] = (p5:4) ; /* P3:0 excluded */
Also See
--SP (Push), SP++ (Pop), SP++ (Pop Multiple)
None

SP++ (Pop)
General Form
dest_reg = [ SP ++ ]
Syntax
mostreg = [ SP ++ ] ; /* post-increment SP; does not apply to
Data Registers and Pointer Registers (a) */
Dreg = [ SP ++ ] ; /* Load Data Register instruction (repeated
here for user convenience) (a) */
Preg = [ SP ++ ] ; /* Load Pointer Register instruction
(repeated here for user convenience) (a) */
Syntax Terminology
mostreg: I3–0, M3–0, B3–0, L3–0, A0.X, A0.W, A1.X, A1.W, ASTAT, RETS,
RETI, RETX, RETN, RETE, LC0, LC1, LT0, LT1, LB0, LB1, USP, SEQSTAT, and
SYSCFG
Dreg: R7–0
Preg: P5–0, FP
Instruction Length
The Pop instruction loads the contents of the stack indexed by the current
Stack Pointer into a specified register. The instruction post-increments
the Stack Pointer to the next occupied location in the stack before
concluding.

Stack Control
decrement operation is used for pushing, and the increment operation is
used for popping values. The Stack Pointer always points to the last used
location. When a pop operation is issued, the value pointed to by the
Stack Pointer is transferred and the SP is replaced by SP+4.
The illustration below shows what the stack would look like when a pop
such as R3 = [ SP ++ ] occurs.
higher memory
Word0
Word1 BEGINNING STATE
Word2 <------- SP
...
lower memory
higher memory
Word0
Word1 LOAD REGISTER R3 FROM STACK
Word2 <------ SP ========> R3 = Word2
...
lower memory
higher memory
Word0 POST-INCREMENT STACK POINTER
Word1 <------ SP
Word2
...
lower memory
The value just popped remains on the stack until another push instruction
overwrites it.

Of course, the usual intent for Pop and these specific Load Register
instructions is to recover register values that were previously pushed onto
the stack. The user must exercise programming discipline to restore the
stack values back to their intended registers from the first-in, last-out
structure of the stack. Pop or load exactly the same registers that were
pushed onto the stack, but pop them in the opposite order.
instruction aborts.
A value cannot be popped off the stack directly into the Stack Pointer.
SP = [SP ++] is an invalid instruction. Refer to “Register Names” on
page 1-6 for more information.
Flags Affected
The ASTAT = [SP++] version of this instruction explicitly affects arith-
metic flags.
Flags are not affected by other versions of this instruction.
Required Mode
User & Supervisor for most cases
Explicit access to USP, SEQSTAT, SYSCFG, RETI, RETX, RETN, and RETE
requires Supervisor mode. A protection violation exception results if any
of these registers are explicitly accessed from User mode.
Parallel Issue
The 16-bit versions of the Load Data Register and Load Pointer Register
instructions can be issued in parallel with specific other instructions. For
details, see “Issuing Parallel Instructions” on page 15-1.
The Pop instruction cannot be issued in parallel with other instructions.

Stack Control
Example
r0 = [sp++] ; /* Load Data Register instruction */
p4 = [sp++] ; /* Load Pointer Register instruction */
i1 = [sp++] ; /* Pop instruction */
reti = [sp++] ; /* Pop instruction; supervisor mode required */
Also See
Load Pointer Register, Load Data Register, --SP (Push), --SP (Push Multi-
ple), SP++ (Pop Multiple)
None

SP++ (Pop Multiple)
General Form
(dest_reg_range) = [ SP ++ ]
Syntax
( R7 : Dreglim, P5 : Preglim ) = [ SP ++ ] ; /* Dregs and
indexed Pregs (a) */
( R7 : Dreglim ) = [ SP ++ ] ; /* Dregs, only (a) */
( P5 : Preglim ) = [ SP ++ ] ; /* indexed Pregs, only (a) */
Syntax Terminology
Dreglim: any number in the range 7 through 0
Preglim: any number in the range 5 through 0
Instruction Length
The Pop Multiple instruction restores the contents of multiple data
and/or Pointer registers from the stack. The range of registers to be
restored always includes the highest index register (R7 and/or P5) plus any
contiguous lower index registers specified by the user down to and includ-
ing R0 and/or P0.
The instructions start by restoring the register having the highest index
then descend to the register with the lowest index. The index of the last
register restored from the stack is specified by the user in the instruction
syntax. Pointer registers are popped before Data registers, if both are spec-
ified in the same instruction.

Stack Control
The instruction post-increments the Stack Pointer to the next occupied

location in the stack before concluding.
decrement operation is used for pushing, and the increment operation is
used for popping values. The Stack Pointer always points to the last used
location. When a pop operation is issued, the value pointed to by the
Stack Pointer is transferred and the SP is replaced by SP+4.
The following graphic shows what the stack would look like when a Pop
Multiple such as (R7:5) = [ SP ++ ] occurs.
higher memory
Word0
Word1
Word2 BEGINNING STATE
Word3 <------ SP
...
lower memory
higher memory
R3
R4
R6 LOAD REGISTER R7 FROM STACK
R7 <------ SP ========> R7 = Word3
...
lower memory

higher memory
R4
R6 <------ SP ========> R6 = Word2
R7
...
lower memory
higher memory.
..
R6 <------ SP ========> R5 = Word1
R7
..
lower memory
higher memory
..
... POST-INCREMENT STACK POINTER
Word0 <------ SP
Word1
Word2
lower memory
The value(s) just popped remain on the stack until another push instruc-
tion overwrites it.
Of course, the usual intent for Pop Multiple is to recover register values
that were previously pushed onto the stack. The user must exercise pro-
gramming discipline to restore the stack values back to their intended

Stack Control
registers from the first-in, last-out structure of the stack. Pop exactly the
same registers that were pushed onto the stack, but pop them in the oppo-
site order.
Although this instruction takes a variable amount of time to complete
depending on the number of registers to be saved, it reduces compiled
code size.
This instruction is not interruptible. Interrupts asserted after the first
issued stack read operation are appended until all the reads complete.
However, exceptions that occur while this instruction is executing cause it
to abort gracefully. For example, a load/store operation might cause a pro-
tection violation while Pop Multiple is executing. In that case, SP is reset
to its original value prior to the execution of this instruction. This mea-
sure ensures that the instruction can be restarted after the exception.
Note that when a Pop Multiple operation aborts due to an exception,
some of the destination registers are changed as a result of loads that have
already completed before the exception.
Only Pointer registers P5–0 can be operands for this instruction; SP and FP
cannot. All data registers R7–0 can be operands for this instruction.
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
Example
(p5:4) = [ sp ++ ] ; /* P3 through P0 excluded */
(r7:2) = [ sp ++ ] ; /* R1 through R0 excluded */
(r7:5, p5:0) = [ sp ++ ] ; /* D-registers R4 through R0
optionally excluded */
Also See
--SP (Push), --SP (Push Multiple), SP++ (Pop)
None

Stack Control
LINK, UNLINK
General Form
LINK, UNLINK
Syntax
LINK uimm18m4 ; /* allocate a stack frame of specified size
(b) */
UNLINK ; /* de-allocate the stack frame (b)*/
Syntax Terminology
of 8 through 262,152 bytes (0x00008 through 0x3FFFC)
Instruction Length
The Linkage instruction controls the stack frame space on the stack and
the Frame Pointer (FP) for that space. LINK allocates the space and UNLINK
de-allocates the space.
LINK saves the current RETS and FP registers to the stack, loads the FP regis-
ter with the new frame address, then decrements the SP by the
user-supplied frame size value.
Typical applications follow the LINK instruction with a Push Multiple
instruction to save pointer and data registers to the stack.

The user-supplied argument for LINK determines the size of the allocated
stack frame. LINK always saves RETS and FP on the stack, so the minimum
frame size is 2 words when the argument is zero. The maximum stack
frame size is 218 + 8 = 262152 bytes in 4-byte increments.
UNLINK performs the reciprocal of LINK, de-allocating the frame space by
moving the current value of FP into SP and restoring previous values into
FP and RETS from the stack.
The UNLINK instruction typically follows a Pop Multiple instruction that

restores pointer and data registers previously saved to the stack.
The frame values remain on the stack until a subsequent Push, Push Mul-
tiple or LINK operation overwrites them.
Of course, FP must not be modified by user code between LINK and
UNLINK to preserve stack integrity.
Neither LINK nor UNLINK can be interrupted. However, exceptions that

occur while either of these instructions is executing cause the instruction
to abort. For example, a load/store operation might cause a protection vio-
lation while LINK is executing. In that case, SP and FP are reset to their
original values prior to the execution of this instruction. This measure
ensures that the instruction can be restarted after the exception.
Note that when a LINK operation aborts due to an exception, the stack
memory may already be changed due to stores that have already completed
before the exception. Likewise, an aborted UNLINK operation may leave the
FP and RETS registers changed because of a load that has already completed
before the interruption.
The illustrations below show the stack contents after executing a LINK
instruction followed by a Push Multiple instruction.

Stack Control
higher memory
...
... AFTER LINK EXECUTES
Saved RETS
Prior FP <-FP
Allocated
words for local
<-SP = FP +– frame_size
subroutine
variables
...
lower memory
higher memory
...
...
AFTER A PUSH
Saved RETS
MULTIPLE EXECUTES
Prior FP <-FP
Allocated
words for local
subroutine
variables
R0
R1
:
R7
P0
:
P5 <-SP
lower memory

Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
link 8 ; /* establish frame with 8 words allocated for local
variables */
[ -- sp ] = (r7:0, p5:0) ; /* save D- and P-registers */
(r7:0, p5:0) = [ sp ++ ] ; /* restore D- and P-registers */
unlink ; /* close the frame* /
Also See
--SP (Push Multiple) SP++ (Pop Multiple)
The Linkage instruction is used to set up and tear down stack frames for a
high-level language like C.

6 CONTROL CODE BIT
MANAGEMENT
Instruction Summary
• “Compare Data Register” on page 6-2
• “Compare Pointer” on page 6-6
• “Compare Accumulator” on page 6-9
• “Move CC” on page 6-12
• “Negate CC” on page 6-15
This chapter discusses the instructions that affect the Control Code (CC)
bit in the ASTAT register. Users can take advantage of these instructions to
set the CC bit based on a comparison of values from two registers, pointers,
or accumulators. In addition, these instructions can move the status of the
CC bit to and from a data register or arithmetic status bit, or they can
negate the status of the CC bit.

Compare Data Register
General Form
CC = operand_1 == operand_2
CC = operand_1 < operand_2
CC = operand_1 <= operand_2
CC = operand_1 < operand_2 (IU)
CC = operand_1 <= operand_2 (IU)
Syntax
CC = Dreg == Dreg ; /* equal, register, signed (a) */
CC = Dreg == imm3 ; /* equal, immediate, signed (a) */
CC = Dreg < Dreg ; /* less than, register, signed (a) */
CC = Dreg < imm3 ; /* less than, immediate, signed (a) */
CC = Dreg <= Dreg ; /* less than or equal, register, signed
(a) */
CC = Dreg <= imm3 ; /* less than or equal, immediate, signed
(a) */
CC = Dreg < Dreg (IU) ; /* less than, register, unsigned
(a) */
CC = Dreg < uimm3 (IU) ; /* less than, immediate, unsigned (a)
*/
CC = Dreg <= Dreg (IU) ; /* less than or equal, register,
unsigned (a) */
CC = Dreg <= uimm3 (IU) ; /* less than or equal, immediate
unsigned (a) */
Syntax Terminology
Dreg: R7–0

uimm3: 3-bit unsigned field, with a range of 0 through 7

Control Code Bit Management
Instruction Length
The Compare Data Register instruction sets the Control Code (CC) bit
based on a comparison of two values. The input operands are D-registers.
The compare operations are nondestructive on the input operands and
affect only the CC bit and the flags. The value of the CC bit determines all
subsequent conditional branching.
The various forms of the Compare Data Register instruction perform
32-bit signed compare operations on the input operands or an unsigned
compare operation, if the (IU) optional mode is appended. The compare
operations perform a subtraction and discard the result of the subtraction
without affecting user registers. The compare operation that you specify
determines the value of the CC bit.
Flags Affected
The Compare Data Register instruction uses the values shown in
Table 6-1 in signed and unsigned compare operations.
Table 6-1. Compare Data Register Values

Comparison Signed Unsigned
Equal AZ=1 n/a
Less than AN=1 AC0=0
Less than or equal AN or AZ=1 AC0=0 or AZ=1

The following flags are affected by the Compare Data Register instruction.
• CC is set if the test condition is true; cleared if false.
• AC0 is set if result generated a carry; cleared if no carry.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
cc = r3 == r2 ;
cc = r7 == 1 ;
/* If r0 = 0x8FFF FFFF and r3 = 0x0000 0001, then the signed
operation . . . */
cc = r0 < r3 ;
/* . . . produces cc = 1, because r0 is treated as a negative
value */
cc = r2 < -4 ;
cc = r6 <= r1 ;
cc = r4 <= 3 ;

/* If r0 = 0x8FFF FFFF and r3 = 0x0000 0001,then the unsigned

operation . . . */
cc = r0 < r3 (iu) ;
/* . . . produces CC = 0, because r0 is treated as a large
unsigned value */
cc = r1 < 0x7 (iu) ;
cc = r2 <= r0 (iu) ;
cc = r3 <= 2 (iu) ;
Also See
Compare Pointer, Compare Accumulator, IF CC JUMP, BITTST
None

Compare Pointer
General Form
CC = operand_1 == operand_2
CC = operand_1 < operand_2
CC = operand_1 <= operand_2
CC = operand_1 < operand_2 (IU)
CC = operand_1 <= operand_2 (IU)
Syntax
CC = Preg == Preg ; /* equal, register, signed (a) */
CC = Preg == imm3 ; /* equal, immediate, signed (a) */
CC = Preg < Preg ; /* less than, register, signed (a) */
CC = Preg < imm3 ; /* less than, immediate, signed (a) */
CC = Preg <= Preg ; /* less than or equal, register, signed
(a) */
CC = Preg <= imm3 ; /* less than or equal, immediate, signed
(a) */
CC = Preg < Preg (IU) ; /* less than, register, unsigned (a) */
CC = Preg < uimm3 (IU) ; /* less than, immediate, unsigned (a) */
CC = Preg <= Preg (IU) ; /* less than or equal, register,
unsigned (a) */
CC = Preg <= uimm3 (IU) ; /* less than or equal, immediate
unsigned (a) */
Syntax Terminology


Instruction Length
The Compare Pointer instruction sets the Control Code (CC) bit based on
a comparison of two values. The input operands are P-registers.
The compare operations are nondestructive on the input operands and
affect only the CC bit and the flags. The value of the CC bit determines all
subsequent conditional branching.
The various forms of the Compare Pointer instruction perform 32-bit
signed compare operations on the input operands or an unsigned compare
operation, if the (IU) optional mode is appended. The compare opera-
tions perform a subtraction and discard the result of the subtraction
without affecting user registers. The compare operation that you specify
determines the value of the CC bit.
Flags Affected

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
cc = p3 == p2 ;
cc = p0 == 1 ;
cc = p0 < p3 ;
cc = p2 < -4 ;
cc = p1 <= p0 ;
cc = p4 <= 3 ;
cc = p5 < p3 (iu) ;
cc = p1 < 0x7 (iu) ;
cc = p2 <= p0 (iu) ;
cc = p3 <= 2 (iu) ;
Also See
Compare Data Register, Compare Accumulator, IF CC JUMP
None

Compare Accumulator
General Form
CC = A0 == A1
CC = A0 < A1
CC = A0 <= A1
Syntax
CC = A0 == A1 ; /* equal, signed (a) */
CC = A0 < A1 ; /* less than, Accumulator, signed (a) */
CC = A0 <= A1 ; /* less than or equal, Accumulator, signed (a) */
Instruction Length
The Compare Accumulator instruction sets the Control Code (CC) bit
based on a comparison of two values. The input operands are
Accumulators.
These instructions perform 40-bit signed compare operations on the
Accumulators. The compare operations perform a subtraction and discard
the result of the subtraction without affecting user registers. The compare
operation that you specify determines the value of the CC bit.
No unsigned compare operations or immediate compare operations are
performed for the Accumulators.
The compare operations are nondestructive on the input operands, and
affect only the CC bit and the flags. All subsequent conditional branching
is based on the value of the CC bit.

Flags Affected
The Compare Accumulator instruction uses the values shown in Table 6-2
in compare operations.
Table 6-2. Compare Accumulator Instruction Values

Comparison Signed
Equal AZ=1
Less than AN=1
Less than or equal AN or AZ=1
The following arithmetic status bits reside in the ASTAT register.

• AC0 is set if result generated a carry; cleared if no carry.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
cc = a0 == a1 ;
cc = a0 < a1 ;
cc = a0 <= a1 ;
Also See
Compare Pointer, Compare Data Register, IF CC JUMP
None

Move CC
General Form
dest = CC
dest |= CC
dest &= CC
dest ^= CC
CC = source
CC |= source
CC &= source
CC ^= source
Syntax
Dreg = CC ; /* CC into 32-bit data register, zero-extended (a)
*/
statbit = CC ; /* status bit equals CC (a) */
statbit |= CC ; /* status bit equals status bit OR CC (a) */
statbit &= CC ; /* status bit equals status bit AND CC (a) */
statbit ^= CC ; /* status bit equals status bit XOR CC (a) */
CC = Dreg ; /* CC set if the register is non-zero (a) */
CC = statbit ; /* CC equals status bit (a) */
CC |= statbit ; /* CC equals CC OR status bit (a) */
CC &= statbit ; /* CC equals CC AND status bit (a) */
CC ^= statbit ; /* CC equals CC XOR status bit (a) */
Syntax Terminology
Dreg: R7–0
statbit: AZ, AN, AC0, AC1, V, VS, AV0, AV0S, AV1, AV1S, AQ
Instruction Length

The Move CC instruction moves the status of the Control Code (CC) bit to
and from a data register or arithmetic status bit.
When copying the CC bit into a 32-bit register, the operation moves the CC
bit into the least significant bit of the register, zero-extended to 32 bits.
The two cases are as follows.
• If CC = 0, Dreg becomes 0x00000000.
• If CC = 1, Dreg becomes 0x00000001.
When copying a data register to the CC bit, the operation sets the CC bit to
1 if any bit in the source data register is set; that is, if the register is non-
zero. Otherwise, the operation clears the CC bit.
Some versions of this instruction logically set or clear an arithmetic status
bit based on the status of the Control Code.
The use of the CC bit as source and destination in the same instruction is
disallowed. See the Negate CC instruction to change CC based solely on its
own value.
Flags Affected
• The Move CC instruction affects flags CC, AZ, AN, AC0, AC1, V, VS,
AV0, AV0S, AV1, AV1S, AQ, according to the status bit and syntax
used, as described in “Syntax” on page 6-12.
• All other flags not explicitly specified by the syntax are unaffected.

ASTAT
on page A-2.

Required Mode
User & Supervisor
Instruction Length
Parallel Issue
Example
r0 = cc ;
az = cc ;
an |= cc ;
ac0 &= cc ;
av0 ^= cc ;
cc = r4 ;
cc = av1 ;
cc |= aq ;
cc &= an ;
cc ^= ac1 ;
Also See
Negate CC
None

Negate CC
General Form
CC = ! CC
Syntax
CC = ! CC ; /* (a) */
Instruction Length
The Negate CC instruction inverts the logical state of CC.
Flags Affected
• CC is toggled from its previous value by the Negate CC instruction.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
cc =! cc ;
Also See
Move CC
None

7 LOGICAL OPERATIONS
Instruction Summary
• “& (AND)” on page 7-2
• “~ (NOT One’s Complement)” on page 7-4
• “| (OR)” on page 7-6
• “^ (Exclusive-OR)” on page 7-8
• “BXORSHIFT, BXOR” on page 7-10
This chapter discusses the instructions that specify logical operations.
Users can take advantage of these instructions to perform logical AND,
NOT, OR, exclusive-OR, and bit-wise exclusive-OR (BXORSHIFT)
operations.

& (AND)
General Form
dest_reg = src_reg_0 & src_reg_1
Syntax
Dreg = Dreg & Dreg ; /* (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The AND instruction performs a 32-bit, bit-wise logical AND operation
on the two source registers and stores the results into the dest_reg.
The instruction does not implicitly modify the source registers. The
dest_reg and one src_reg can be the same D-register. This would explic-
itly modifies the src_reg.
Flags Affected
The AND instruction affects flags as follows.
• AZ is set if the final result is zero, cleared if nonzero.
• AN is set if the result is negative, cleared if non-negative.

Logical Operations
• AC0 and V are cleared.


ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r4 = r4 & r3 ;
Also See
| (OR)
None

~ (NOT One’s Complement)
General Form
dest_reg = ~ src_reg
Syntax
Dreg = ~ Dreg ; /* (a)*/
Syntax Terminology
Dreg: R7–0
Instruction Length
The NOT One’s Complement instruction toggles every bit in the 32-bit
register.
The instruction does not implicitly modify the src_reg. The dest_reg
and src_reg can be the same D-register. Using the same D-register as the
dest_reg and src_reg would explicitly modify the src_reg.
Flags Affected
The NOT One’s Complement instruction affects flags as follows.

Logical Operations


ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r3 = ~ r4 ;
Also See
Negate (Two’s Complement)
None

| (OR)
General Form
dest_reg = src_reg_0 | src_reg_1
Syntax
Dreg = Dreg | Dreg ; /* (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The OR instruction performs a 32-bit, bit-wise logical OR operation on
the two source registers and stores the results into the dest_reg.
The instruction does not implicitly modify the source registers. The
Flags Affected
The OR instruction affects flags as follows.

Logical Operations


ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r4 = r4 | r3 ;
Also See
^ (Exclusive-OR), BXORSHIFT, BXOR
None

^ (Exclusive-OR)
General Form
dest_reg = src_reg_0 ^ src_reg_1
Syntax
Dreg = Dreg ^ Dreg ; /* (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Exclusive-OR (XOR) instruction performs a 32-bit, bit-wise logical
exclusive OR operation on the two source registers and loads the results
into the dest_reg.
The XOR instruction does not implicitly modify source registers. The
Flags Affected
The XOR instruction affects flags as follows.

Logical Operations


ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r4 = r4 ^ r3 ;
Also See
| (OR), BXORSHIFT, BXOR
None

BXORSHIFT, BXOR
General Form
dest_reg = CC = BXORSHIFT ( A0, src_reg )
dest_reg = CC = BXOR ( A0, src_reg )
dest_reg = CC = BXOR ( A0, A1, CC )
A0 = BXORSHIFT ( A0, A1, CC )
Syntax
LFSR Type I (Without Feedback)
Dreg_lo = CC = BXORSHIFT ( A0, Dreg ) ; /* (b) */
Dreg_lo = CC = BXOR ( A0, Dreg ) ; /* (b) */
LFSR Type I (With Feedback)

Dreg_lo = CC = BXOR ( A0, A1, CC ) ; /* (b) */
A0 = BXORSHIFT ( A0, A1, CC ) ; /* (b) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Instruction Length
Four Bit-Wise Exclusive-OR (BXOR) instructions support two different
types of linear feedback shift register (LFSR) implementations.

Logical Operations
The Type I LFSRs (no feedback) applies a 32-bit registered mask to a

40-bit state residing in Accumulator A0, followed by a bit-wise XOR
reduction operation. The result is placed in CC and a destination register
half.
The Type I LFSRs (with feedback) applies a 40-bit mask in Accumulator A1
to a 40-bit state residing in A0. The result is shifted into A0.
In the following circuits describing the BXOR instruction group, a
bit-wise XOR reduction is defined as:
Out = ( ( ( ( ( B 0 ⊕ B 1 ) ⊕ B 2 ) ⊕ B 3 ) ⊕ ... ) ⊕ B n – 1 )
where B0 through BN–1 represent the N bits that result from masking the
contents of Accumulator A0 with the polynomial stored in either A1 or a
32-bit register. The instruction descriptions are shown in Figure 7-1.
s(D)
D[0] D[1]
A0[0] A0[1]
Figure 7-1. Bit-Wise Exclusive-OR Reduction
In the figure above, the bits A0 bit 0 and A0 bit 1 are logically AND’ed
with bits D[0] and D[1]. The result from this operation is XOR reduced
according to the following formula.
s ( D ) = ( A0 [ 0 ]&D [ 0 ] ) ⊕ ( A0 [ 1 ]&D [ 1 ] )

Modified Type I LFSR (without feedback)

Two instructions support the LSFR with no feedback.
Dreg_lo = CC = BXORSHIFT(A0, dreg)
Dreg_lo = CC = BXOR(A0, dreg)
In the first instruction the Accumulator A0 is left-shifted by 1 prior to the

XOR reduction. This instruction provides a bit-wise XOR of A0 logically
AND’ed with a dreg. The result of the operation is placed into both the CC
flag and the least significant bit of the destination register. The operation
is shown in Figure 7-2.
The upper 15 bits of dreg_lo are overwritten with zero, and dr[0] = IN
after the operation.
The second instruction in this class performs a bit-wise XOR of A0 logi-
cally AND'ed with the dreg. The output is placed into the least significant
bit of the destination register and into the CC bit. The Accumulator A0 is
not modified by this operation. This operation is illustrated in Figure 7-3.
The upper 15 bits of dreg_lo are overwritten with zero, and dr[0] = IN
after the operation.
Modified Type I LFSR (with feedback)

Two instructions support the LFSR with feedback.
A0 = BXORSHIFT(A0, A1, CC)
Dreg_lo = CC = BXOR(A0, A1, CC)
The first instruction provides a bit-wise XOR of A0 logically AND'ed with

A1. The resulting intermediate bit is XOR'ed with the CC flag. The result
of the operation is left-shifted into the least significant bit of A0 following
the operation. This operation is illustrated in Figure 7-4. The CC bit is not
modified by this operation.

Logical Operations
Before XOR Reduction
A0[39] A0[38] A0[37] A0[0] 0

A0[39:0] Left Shift by 1
XOR Reduction
0 + + + + CC dreg_lo
IN
D[31] D[2] D[1] D[0]
A0[38] A0[30] A0[1] A0[0] 0
After Operation
dr[15] dr[14] dr[13] IN
dreg_lo[15:0]
Figure 7-2. A0 Left-Shifted by 1 Followed by XOR Reduction
The second instruction in this class performs a bit-wise XOR of A0 logi-

cally AND'ed with A1. The resulting intermediate bit is XOR'ed with the
CC flag. The result of the operation is placed into both the CC flag and the
least significant bit of the destination register.
This operation is illustrated in Figure 7-5.
The Accumulator A0 is not modified by this operation. The upper 15 bits
of dreg_lo are overwritten with zero, and dr[0] = IN.

XOR Reduction
0 + + + + CC dreg_lo
IN
D[31] D[2] D[1] D[0]
A0[39] A0[31] A0[2] A0[1] A0[0]
After Operation
dr[15] dr[14] dr[13] IN
dreg_lo[15:0]
Figure 7-3. XOR of A0, Logical AND with the D-Register
Flags Affected
The following flags are affected by the Four Bit-Wise Exclusive-OR
instructions.
• CCis set or cleared according to the Functional Description for the
BXOR and the nonfeedback version of the BXORSHIFT instruction.
The feedback version of the BXORSHIFT instruction affects no flags.

ASTAT

on page A-2.

Logical Operations
CC + + + +
Left Shift by 1
A1[39] A1[38] A1[37] A1[0] Following XOR
Reduction
IN
A0[39] A0[38] A0[37] A0[0]
After Operation
A0[38] A0[37] A0[36] IN
A0[39:0]
Figure 7-4. XOR of A0 Logical AND with A1 with Results Left-Shifted

into LSB of A0
Required Mode
User & Supervisor
Parallel Issue
cific other 16-bit instructions. For details, see “Issuing Parallel
Example
r0.l = cc = bxorshift (a0, r1) ;
r0.l = cc = bxor (a0, r1) ;
r0.l = cc = bxor (a0, a1, cc) ;
a0 = bxorshift (a0, a1, cc) ;

CC + + + CC dreg_lo[0]
IN
A1[39] A1[38] A1[37] A1[0]
A0[39] A0[38] A0[37] A0[0]
After Operation
dr[15] dr[14] dr[13] IN
dreg_lo[15:0]
Figure 7-5. XOR of A0 Logical AND with A1 with Results Placed in CC

Flag and LSB of Destination Register
Also See
None
Linear feedback shift registers (LFSRs) can multiply and divide polynomi-
als and are often used to implement cyclical encoders and decoders.
LFSRs use the set of Bit-Wise XOR instructions to compute bit XOR
reduction from a state masked by a polynomial.

8 BIT OPERATIONS
Instruction Summary
• “BITCLR” on page 8-2
• “BITSET” on page 8-4
• “BITTGL” on page 8-6
• “BITTST” on page 8-8
• “DEPOSIT” on page 8-10
• “EXTRACT” on page 8-16
• “BITMUX” on page 8-21
• “ONES (One’s Population Count)” on page 8-26
This chapter discusses the instructions that specify bit operations. Users
can take advantage of these instructions to set, clear, toggle, and test bits.
They can also merge bit fields and save the result, extract specific bits from
a register, merge bit streams, and count the number of ones in a register.

BITCLR
General Form
BITCLR ( register, bit_position )
Syntax
BITCLR ( Dreg , uimm5 ) ; /* (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Bit Clear instruction clears the bit designated by bit_position in the
specified D-register. It does not affect other bits in that register.
The bit_position range of values is 0 through 31, where 0 indicates the
LSB, and 31 indicates the MSB of the 32-bit D-register.
Flags Affected
The Bit Clear instruction affects flags as follows.
• AC0 is cleared.

Bit Operations
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
bitclr (r2, 3) ; /* clear bit 3 (the fourth bit from LSB) in
R2 */
For example, if R2 contains 0xFFFFFFFF before this instruction, it con-

tains 0xFFFFFFF7 after the instruction.
Also See
BITSET, BITTST, BITTGL
None

BITSET
General Form
BITSET ( register, bit_position )
Syntax
BITSET ( Dreg , uimm5 ) ; /* (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Bit Set instruction sets the bit designated by bit_position in the
specified D-register. It does not affect other bits in the D-register.
Flags Affected
The Bit Set instruction affects flags as follows.
• AZ is cleared.
• AC0 is cleared.

Bit Operations
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
bitset (r2, 7) ; /* set bit 7 (the eighth bit from LSB) in
R2 */
For example, if R2 contains 0x00000000 before this instruction, it con-

tains 0x00000080 after the instruction.
Also See
BITCLR, BITTST, BITTGL
None

BITTGL
General Form
BITTGL ( register, bit_position )
Syntax
BITTGL ( Dreg , uimm5 ) ; /* (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Bit Toggle instruction inverts the bit designated by bit_position in
the specified D-register. The instruction does not affect other bits in the
D-register.
Flags Affected
The Bit Toggle instruction affects flags as follows.
• AC0 is cleared.

Bit Operations
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
bittgl (r2, 24) ; /* toggle bit 24 (the 25th bit from LSB in
R2 */
For example, if R2 contains 0xF1FFFFFF before this instruction, it con-

tains 0xF0FFFFFF after the instruction. Executing the instruction a
second time causes the register to contain 0xF1FFFFFF.
Also See
BITSET, BITTST, BITCLR
None

BITTST
General Form
CC = BITTST ( register, bit_position )
CC = ! BITTST ( register, bit_position )
Syntax
CC = BITTST ( Dreg , uimm5 ) ; /* set CC if bit = 1 (a)*/
CC = ! BITTST ( Dreg , uimm5 ) ; /* set CC if bit = 0 (a)*/
Syntax Terminology
Dreg: R7–0
Instruction Length
The Bit Test instruction sets or clears the CC bit, based on the bit desig-
nated by bit_position in the specified D-register. One version tests
whether the specified bit is set; the other tests whether the bit is clear. The
instruction does not affect other bits in the D-register.

Bit Operations
Flags Affected
The Bit Test instruction affects flags as follows.
• CC is set if the tested bit is 1; cleared otherwise.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
cc = bittst (r7, 15) ; /* test bit 15 TRUE in R7 */
For example, if R7 contains 0xFFFFFFFF before this instruction, CC is set

to 1, and R7 still contains 0xFFFFFFFF after the instruction.
cc = ! bittst (r3, 0) ; /* test bit 0 FALSE in R3 */
If R3 contains 0xFFFFFFFF, this instruction clears CC to 0.
Also See
BITCLR, BITSET, BITTGL
None

DEPOSIT
General Form
dest_reg = DEPOSIT ( backgnd_reg, foregnd_reg )
dest_reg = DEPOSIT ( backgnd_reg, foregnd_reg ) (X)
Syntax
Dreg = DEPOSIT ( Dreg, Dreg ) ; /* no extension (b) */
Dreg = DEPOSIT ( Dreg, Dreg ) (X) ; /* sign-extended (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Bit Field Deposit instruction merges the background bit field in
backgnd_reg with the foreground bit field in the upper half of
foregnd_reg and saves the result into dest_reg. The user determines the
length of the foreground bit field and its position in the background field.
The input register bit field definitions appear in Table 8-1.

Bit Operations
Table 8-1. Input Register Bit Field Definitions

31................24 23................16 15..................8 7....................0
backgnd_reg:1 bbbb bbbb bbbb bbbb bbbb bbbb bbbb bbbb
foregnd_reg:2 nnnn nnnn nnnn nnnn xxxp pppp xxxL LLLL
1 where b = background bit field (32 bits)

2 where:
–n = foreground bit field (16 bits); the L field determines the actual number of foreground bits
used.
–p = intended position of foreground bit field LSB in dest_reg (valid range 0 through 31)
–L = length of foreground bit field (valid range 0 through 16)
The operation writes the foreground bit field of length L over the back-
ground bit field with the foreground LSB located at bit p of the
background. See “Example,” below, for more.
Boundary Cases
Consider the following boundary cases.
• Unsigned syntax, L = 0: The architecture copies backgnd_reg con-
tents without modification into dest_reg. By definition, a
foreground of zero length is transparent.
• Sign-extended, L = 0 and p = 0: This case loads 0x0000 0000 into
dest_reg. The sign of a zero length, zero position foreground is
zero; therefore, sign-extended is all zeros.

• Sign-extended, L = 0 and p = 0: The architecture copies the lower

order bits of backgnd_reg below position p into dest_reg, then
sign-extends that number. The foreground value has no effect. For
instance, if:
backgnd_reg = 0x0000 8123,
L = 0, and
p = 16,
then:
dest_reg = 0xFFFF 8123.
In this example, the architecture copies bits 15–0 from
backgnd_reg into dest_reg, then sign-extends that number.
• Sign-extended, (L + p) > 32: Any foreground bits that fall outside

the range 31–0 are truncated.
The Bit Field Deposit instruction does not modify the contents of the two
source registers. One of the source registers can also serve as dest_reg.
Options
The (X) syntax sign-extends the deposited bit field. If you specify the
sign-extended syntax, the operation does not affect the dest_reg bits that
are less significant than the deposited bit field.
Flags Affected
This instruction affects flags as follows.
• AC0 is cleared.

Bit Operations
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
Bit Field Deposit Unsigned
r7 = deposit (r4, r3) ;
• If
• R4=0b1111 1111 1111 1111 1111 1111 1111 1111
where this is the background bit field
• R3=0b0000 0000 0000 0000 0000 0111 0000 0011
where bits 31–16 are the foreground bit field, bits 15–8 are
the position, and bits 7–0 are the length
then the Bit Field Deposit (unsigned) instruction produces:
• R7=0b1111 1111 1111 1111 1111 1100 0111 1111

• If
• R4=0b1111 1111 1111 1111 1111 1111 1111 1111
• R3=0b0000 0000 1111 1010 0000 1101 0000 1001
• R7=0b1111 1111 1101 1111 0101 1111 1111 1111
Bit Field Deposit Sign-Extended

r7 = deposit (r4, r3) (x) ; /* sign-extended*/
• If
• R4=0b1111 1111 1111 1111 1111 1111 1111 1111
• R3=0b0101 1010 0101 1010 0000 0111 0000 0011
• R7=0b0000 0000 0000 0000 0000 0001 0111 1111
• If
• R4=0b1111 1111 1111 1111 1111 1111 1111 1111
• R3=0b0000 1001 1010 1100 0000 1101 0000 1001

Bit Operations

• R7=0b1111 1111 1111 0101 1001 1111 1111 1111
Also See
EXTRACT
Video image overlay algorithms

EXTRACT
General Form
dest_reg = EXTRACT ( scene_reg, pattern_reg ) (Z)
dest_reg = EXTRACT ( scene_reg, pattern_reg ) (X)
Syntax
Dreg = EXTRACT ( Dreg, Dreg_lo ) (Z) ; /* zero-extended (b)*/
Dreg = EXTRACT ( Dreg, Dreg_lo ) (X) ; /* sign-extended (b)*/
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Instruction Length
The Bit Field Extraction instruction moves only specific bits from the
scene_reg into the low-order bits of the dest_reg. The user determines
the length of the pattern bit field and its position in the scene field.
The input register bit field definitions appear in Table 8-2.

Bit Operations
Table 8-2. Input Register Bit Field Definitions

31................24 23................16 15..................8 7....................0
scene_reg:1 ssss ssss ssss ssss ssss ssss ssss ssss
pattern_reg:2 xxxp pppp xxxL LLLL
1 where s = scene bit field (32 bits)

2 where:
–p = position of pattern bit field LSB in scene_reg (valid range 0 through 31)
–L = length of pattern bit field (valid range 0 through 31)
The operation reads the pattern bit field of length L from the scene bit
field, with the pattern LSB located at bit p of the scene. See “Example”,
below, for more.
Boundary Case
If (p + L) > 32: In the zero-extended and sign-extended versions of the
instruction, the architecture assumes that all bits to the left of the
scene_reg are zero. In such a case, the user is trying to access more bits
than the register actually contains. Consequently, the architecture fills any
undefined bits beyond the MSB of the scene_reg with zeros.
The Bit Field Extraction instruction does not modify the contents of the
two source registers. One of the source registers can also serve as dest_reg.
Options
The user has the choice of using the (X) syntax to perform sign-extend
extraction or the (Z) syntax to perform zero-extend extraction.
Flags Affected

• AC0 is cleared.
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
Bit Field Extraction Unsigned
r7 = extract (r4, r3.l) (z) ; /* zero-extended*/
• If
• R4=0b1010 0101 1010 0101 1100 0011 1010 1010
where this is the scene bit field
• R3=0bxxxx xxxx xxxx xxxx 0000 0111 0000 0100
where bits 15–8 are the position, and bits 7–0 are the length
then the Bit Field Extraction (unsigned) instruction produces:
• R7=0b0000 0000 0000 0000 0000 0000 0000 0111

Bit Operations
• If
• R4=0b1010 0101 1010 0101 1100 0011 1010 1010
where bits bits 15–8 are the position, and bits 7–0 are the
length
then the Bit Field Extraction (unsigned) instruction produces:
• R7=0b0000 0000 0000 0000 0000 0001 0010 1110
Bit Field Extraction Sign-Extended

r7 = extract (r4, r3.l) (x) ; /* sign-extended*/
• If
• R4=0b1010 0101 1010 0101 1100 0011 1010 1010
where bits 15–8 are the position, and bits 7–0 are the length
then the Bit Field Extraction (sign-extended) instruction produces:
• R7=0b0000 0000 0000 0000 0000 0000 0000 0111
• IF
• R4=0b1010 0101 1010 0101 1100 0011 1010 1010
where bits bits 15–8 are the position, and bits 7–0 are the
length

Then the Bit Field Extraction (sign-extended) instruction

produces:
• R7=0b1111 1111 1111 1111 1111 1111 0010 1110
Also See
DEPOSIT
Video image pattern recognition and separation algorithms

Bit Operations
BITMUX
General Form
BITMUX ( source_1, source_0, A0 ) (ASR)
BITMUX ( source_1, source_0, A0 ) (ASL)
Syntax
BITMUX ( Dreg , Dreg , A0 ) (ASR) ; /* shift right, LSB is
shifted out (b) */
BITMUX ( Dreg , Dreg , A0 ) (ASL) ; /* shift left, MSB is
shifted out (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Bit Multiplex instruction merges bit streams.
The instruction has two versions, Shift Right and Shift Left. This instruc-
tion overwrites the contents of source_1 and source_0. See Table 8-3,
Table 8-4, and Table 8-5.
In the Shift Right version, the processor performs the following sequence.
1. Right shift Accumulator A0 by one bit. Right shift the LSB of
source_1 into the MSB of the Accumulator.
2. Right shift Accumulator A0 by one bit. Right shift the LSB of

source_0 into the MSB of the Accumulator.

In the Shift Left version, the processor performs the following sequence.
1. Left shift Accumulator A0 by one bit. Left shift the MSB of
source_0 into the LSB of the Accumulator.
2. Left shift Accumulator A0 by one bit. Left shift the MSB of

source_1 into the LSB of the Accumulator.
source_1 and source_0 must not be the same D-register.

Bit Operations
Table 8-5. A Shift Left Instruction

IF 39............32 31............24 23............16 15..............8 7................0
source_1:1 xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx0
source_0:2 yyyy yyyy yyyy yyyy yyyy yyyy yyyy yyy0
Accumulator A0:3 zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzyx
1 source_1 is shifted left 1 place

2 source_0 is shifted left 1 place
3 Accumulator A0 is shifted left 2 places
Table 8-3. Contents Before Shift

IF 39............32 31............24 23............16 15..............8 7................0
source_1: xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
source_0: yyyy yyyy yyyy yyyy yyyy yyyy yyyy yyyy
Accumulator A0: zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz
Table 8-4. A Shift Right Instruction

IF 39............32 31............24 23............16 15..............8 7................0
source_1:1 0xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
source_0:2 0yyy yyyy yyyy yyyy yyyy yyyy yyyy yyyy
Accumulator A0:3 yxzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz zzzz
1 source_1 is shifted right 1 place

2 source_0 is shifted right 1 place
3 Accumulator A0 is shifted right 2 places

Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
bitmux (r2, r3, a0) (asr) ; /* right shift*/
• If
• R2=0b1010 0101 1010 0101 1100 0011 1010 1010
• R3=0b1100 0011 1010 1010 1010 0101 1010 0101
• A0=0b0000 0000 0000 0000 0000 0000 0000 0000 0000 0111

Bit Operations
then the Shift Right instruction produces:

• R2=0b0101 0010 1101 0010 1110 0001 1101 0101
• R3=0b0110 0001 1101 0101 0101 0010 1101 0010
• A0=0b1000 0000 0000 0000 0000 0000 0000 0000 0000 0001
bitmux (r3, r2, a0) (asl) ; /* left shift*/
• If
• R3=0b1010 0101 1010 0101 1100 0011 1010 1010
• R2=0b1100 0011 1010 1010 1010 0101 1010 0101
• A0=0b0000 0000 0000 0000 0000 0000 0000 0000 0000 0111
then the Shift Left instruction produces:

• R2=0b1000 0111 0101 0101 0100 1011 0100 1010
• R3=0b0100 1011 0100 1011 1000 0111 0101 0100
• A0=0b0000 0000 0000 0000 0000 0000 0000 0000 0001 1111
Also See
None
Convolutional encoder algorithms

ONES (One’s Population Count)
General Form
dest_reg = ONES src_reg
Syntax
Dreg_lo = ONES Dreg ; /* (b) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Instruction Length
The One’s Population Count instruction loads the number of 1’s con-
tained in the src_reg into the lower half of the dest_reg.
The range of possible values loaded into dest_reg is 0 through 32.
The dest_reg and src_reg can be the same D-register. Otherwise, the
One’s Population Count instruction does not modify the contents of
src_reg.

Bit Operations
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r3.l = ones r7 ;
If R7 contains 0xA5A5A5A5, R3.L contains the value 16, or 0x0010.

If R7 contains 0x00000081, R3.L contains the value 2, or 0x0002.
Also See
None
Software parity testing


9 SHIFT/ROTATE OPERATIONS
Instruction Summary
• “Add with Shift” on page 9-2
• “Shift with Add” on page 9-5
• “Arithmetic Shift” on page 9-7
• “Logical Shift” on page 9-14
• “ROT (Rotate)” on page 9-21
This chapter discusses the instructions that manipulate bit operations.
Users can take advantage of these instructions to perform logical and
arithmetic shifts, combine addition operations with shifts, and rotate a
registered number through the Control Code (CC) bit.

Add with Shift
General Form
dest_pntr = (dest_pntr + src_reg) << 1
dest_pntr = (dest_pntr + src_reg) << 2
dest_reg = (dest_reg + src_reg) << 1
dest_reg = (dest_reg + src_reg) << 2
Syntax
Pointer Operations
Preg = ( Preg + Preg ) << 1 ; /* dest_reg = (dest_reg +
src_reg) x 2 (a) */
Preg = ( Preg + Preg ) << 2 ; /* dest_reg = (dest_reg +
src_reg) x 4 (a) */
Data Operations
Dreg = (Dreg + Dreg) << 1 ; /* dest_reg = (dest_reg + src_reg)
x 2 (a) */
Dreg = (Dreg + Dreg) << 2 ; /* dest_reg = (dest_reg + src_reg)
x 4 (a) */
Syntax Terminology
Preg: P5–0
Dreg: R7–0
Instruction Length

Shift/Rotate Operations
The Add with Shift instruction combines an addition operation with a
one- or two-place logical shift left. Of course, a left shift accomplishes a x2
multiplication on sign-extended numbers. Saturation is not supported.
The Add with Shift instruction does not intrinsically modify values that
are strictly input. However, dest_reg serves as an input as well as the
result, so dest_reg is intrinsically modified.
Flags Affected
The D-register versions of this instruction affect flags as follows.
• V is set if result overflows; cleared if no overflow.

ASTAT
on page A-2.
The P-register versions of this instruction do not affect any flags.
Required Mode
User & Supervisor
Parallel Issue

Example
p3 = (p3+p2)<<1 ; /* p3 = (p3 + p2) * 2 */
p3 = (p3+p2)<<2 ; /* p3 = (p3 + p2) * 4 */
r3 = (r3+r2)<<1 ; /* r3 = (r3 + r2) * 2 */
r3 = (r3+r2)<<2 ; /* r3 = (r3 + r2) * 4 */
Also See
Shift with Add, Logical Shift, Arithmetic Shift, Add, Multiply 32-Bit
Operands
None

Shift with Add
General Form
dest_pntr = adder_pntr + ( src_pntr << 1 )
dest_pntr = adder_pntr + ( src_pntr << 2 )
Syntax
Preg = Preg + ( Preg << 1 ) ; /* adder_pntr + (src_pntr x 2)
(a) */
Preg = Preg + ( Preg << 2 ) ; /* adder_pntr + (src_pntr x 4)
(a) */
Syntax Terminology
Preg: P5–0
Instruction Length
The Shift with Add instruction combines a one- or two-place logical shift
left with an addition operation.
The instruction provides a shift-then-add method that supports a rudi-
mentary multiplier sequence useful for array pointer manipulation.
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
Example
p3 = p0+(p3<<1) ; /* p3 = (p3 * 2) + p0 */
p3 = p0+(p3<<2) ; /* p3 = (p3 * 4) + p0 */
Also See
Add with Shift, Logical Shift, Arithmetic Shift, Add, Multiply 32-Bit
Operands
None

Arithmetic Shift
General Form
dest_reg >>>= shift_magnitude
dest_reg = src_reg >>> shift_magnitude (opt_sat)
dest_reg = src_reg << shift_magnitude (S)
accumulator = accumulator >>> shift_magnitude
dest_reg = ASHIFT src_reg BY shift_magnitude (opt_sat)
accumulator = ASHIFT accumulator BY shift_magnitude
Syntax
Constant Shift Magnitude
Dreg >>>= uimm5 ; /* arithmetic right shift (a) */
Dreg <<= uimm5 ; /* logical left shift (a) */
Dreg_lo_hi = Dreg_lo_hi >>> uimm4 ; /* arithmetic right shift
(b) */
Dreg_lo_hi = Dreg_lo_hi << uimm4 (S) ; /* arithmetic left
shift (b) */
Dreg = Dreg >>> uimm5 ; /* arithmetic right shift (b) */
Dreg = Dreg << uimm5 (S) ; /* arithmetic left shift (b) */
A0 = A0 >>> uimm5 ; /* arithmetic right shift (b) */
A0 = A0 << uimm5 ; /* logical left shift (b) */
A1 = A1 >>> uimm5 ; /* arithmetic right shift (b) */
A1 = A1 << uimm5 ; /* logical left shift (b) */
Registered Shift Magnitude

Dreg >>>= Dreg ; /* arithmetic right shift (a) */
Dreg <<= Dreg ; /* logical left shift (a) */
Dreg_lo_hi = ASHIFT Dreg_lo_hi BY Dreg_lo (opt_sat) ; /*
arithmetic right shift (b) */
Dreg = ASHIFT Dreg BY Dreg_lo (opt_sat) ; /* arithmetic right
shift (b) */

A0 = ASHIFT A0 BY Dreg_lo ; /* arithmetic right shift (b)*/

A1 = ASHIFT A1 BY Dreg_lo ; /* arithmetic right shift (b)*/
Syntax Terminology
Dreg: R7–0
Dreg_lo_hi: R7–0.L, R7–0.H
Dreg_lo: R7–0.L

opt_sat: optional “(S)” (without the quotes) to invoke saturation of the
result. Not optional on versions that show “(S)” in the syntax.
Instruction Length
The Arithmetic Shift instruction shifts a registered number a specified dis-
tance and direction while preserving the sign of the original number. The
sign bit value back-fills the left-most bit positions vacated by the arith-
metic right shift.
Specific versions of arithmetic left shift are supported, too. Arithmetic left
shift saturates the result if the value is shifted too far. A left shift that
would otherwise lose nonsign bits off the left-hand side saturates to the
maximum positive or negative value instead.

The “ASHIFT” versions of this instruction support two modes.

1. Default–arithmetic right shifts and logical left shifts. Logical left
shifts do not guarantee sign bit preservation. The “ASHIFT” versions
automatically select arithmetic and logical shift modes based on the
sign of the shift_magnitude.
2. Saturation mode–arithmetic right and left shifts that saturate if the
value is shifted left too far.
The “>>>=” and “>>>” versions of this instruction supports only arithmetic
right shifts. If left shifts are desired, the programmer must explicitly use
arithmetic “<<” (saturating) or logical “<<” (non-saturating) instructions.
L Logical left shift instructions are duplicated in the Syntax section

for programmer convenience. See the Logical Shift instruction for
details on those operations.
The Arithmetic Shift instruction supports 16-bit and 32-bit instruction
length.
• The “>>>=” syntax instruction is 16 bits in length, allowing for
smaller code at the expense of flexibility.
• The “>>>”, “<<”, and “ASHIFT” syntax instructions are 32 bits in
length, providing a separate source and destination register, alter-
native data sizes, and parallel issue with Load/Store instructions.
Both syntaxes support constant and registered shift magnitudes.
For the ASHIFT versions, the sign of the shift magnitude determines the
direction of the shift.
• Positive shift magnitudes produce Logical Left shifts.
• Negative shift magnitudes produce Arithmetic Right shifts.

Table 9-1. Arithmetic Shifts

Syntax Description
“>>>=” The value in dest_reg is right-shifted by the number of places specified

by shift_magnitude. The data size is always 32 bits long. The entire 32
bits of the shift_magnitude determine the shift value. Shift magnitudes
larger than 0x1F result in either 0x00000000 (when the input value is
positive) or 0xFFFFFFFF (when the input value is negative).
Only right shifting is supported in this syntax; there is no equivalent
“<<<=” arithmetic left shift syntax. However, logical left shift is sup-
ported. See the Logical Shift instruction.
“>>>”, “<<”, and The value in src_reg is shifted by the number of places specified in
“ASHIFT” shift_magnitude, and the result is stored into dest_reg.
The “ASHIFT” versions can shift 32-bit Dreg and 40-bit Accumulator
registers by up to –32 through +31 places.
In essence, the magnitude is the power of 2 multiplied by the src_reg

number. Positive magnitudes cause multiplication ( N x 2n ) whereas neg-
ative magnitudes produce division ( N x 2-n or N / 2n ).
The dest_reg and src_reg can be a 16-, 32-, or 40-bit register. Some ver-
sions of the Arithmetic Shift instruction support optional saturation.
For 16-bit src_reg, valid shift magnitudes are –16 through +15, zero
included. For 32- and 40-bit src_reg, valid shift magnitudes are –32
through +31, zero included.
The D-register versions of this instruction shift 16 or 32 bits for half-word
and word registers, respectively. The Accumulator versions shift all 40 bits
of those registers.
The D-register versions of this instruction do not implicitly modify the
src_reg values. Optionally, dest_reg can be the same D-register as
src_reg. Doing this explicitly modifies the source register.
The Accumulator versions always modify the Accumulator source value.

Options
Option (S) invokes saturation of the result.
In the default case–without the saturation option–numbers can be
left-shifted so far that all the sign bits overflow and are lost. However,
when the saturation option is enabled, a left shift that would otherwise
shift nonsign bits off the left-hand side saturates to the maximum positive
or negative value instead. Consequently, with saturation enabled, the
result always keeps the same sign as the original number.
Flags Affected
The versions of this instruction that send results to a Dreg set flags as
follows.
The versions of this instruction that send results to an Accumulator A0 set
flags as follows.
• AV0 is set if result is zero; cleared if nonzero.
• AV0S is set if AV0 is set; unaffected otherwise.


flags as follows.
• AV1 is set if result is zero; cleared if nonzero.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
r0 >>>= 19 ; /* 16-bit instruction length arithmetic right
shift */
r3.l = r0.h >>> 7 ; /* arithmetic right shift, half-word */
r3.h = r0.h >>> 5 ; /* same as above; any combination of upper
and lower half-words is supported */

r3.l = r0.h >>> 7(s) ; /* arithmetic right shift, half-word,

saturated */
r4 = r2 >>> 20 ; /* arithmetic right shift, word */
A0 = A0 >>> 1 ; /* arithmetic right shift, Accumulator */
r0 >>>= r2 ; /* 16-bit instruction length arithmetic right
shift */
r3.l = r0.h << 12 (S) ; /* arithmetic left shift */
r5 = r2 << 24(S) ; /* arithmetic left shift */
r3.l = ashift r0.h by r7.l ; /* shift, half-word */
r3.h = ashift r0.l by r7.l ;
r3.h = ashift r0.h by r7.l ;
r3.l = ashift r0.l by r7.l ;
r3.l = ashift r0.h by r7.l(s) ; /* shift, half-word,
saturated */
r3.h = ashift r0.l by r7.l(s) ; /* shift, half-word,
saturated */
r3.h = ashift r0.h by r7.l(s) ;
r3.l = ashift r0.l by r7.l (s) ;
r4 = ashift r2 by r7.l ; /* shift, word */
r4 = ashift r2 by r7.l (s) ; /* shift, word, saturated */
A0 = ashift A0 by r7.l ; /* shift, Accumulator */
A1 = ashift A1 by r7.l ; /* shift, Accumulator */
// If r0.h = -64, then performing . . .
r3.h = r0.h >>> 4 ; /* . . . produces r3.h = -4, preserving the
sign */
Also See
Vector Arithmetic Shift, Vector Logical Shift, Logical Shift, Shift with
Add, ROT (Rotate)
Multiply, divide, and normalize signed numbers

Logical Shift
General Form
dest_pntr = src_pntr >> 1
dest_pntr = src_pntr >> 2dest_pntr = src_pntr << 1
dest_pntr = src_pntr << 2dest_reg >>= shift_magnitude
dest_reg <<= shift_magnitude
dest_reg = src_reg >> shift_magnitude
dest_reg = src_reg << shift_magnitude
dest_reg = LSHIFT src_reg BY shift_magnitude
Syntax
Pointer Shift, Fixed Magnitude
Preg = Preg >> 1 ; /* right shift by 1 bit (a) */
Preg = Preg >> 2 ; /* right shift by 2 bit (a) */
Preg = Preg << 1 ; /* left shift by 1 bit (a) */
Preg = Preg << 2 ; /* left shift by 2 bit (a) */
Data Shift, Constant Shift Magnitude

Dreg >>= uimm5 ; /* right shift (a) */
Dreg <<= uimm5 ; /* left shift (a) */
Dreg_lo_hi = Dreg_lo_hi >> uimm4 ; /* right shift (b) */
Dreg_lo_hi = Dreg_lo_hi << uimm4 ; /* left shift (b) */
Dreg = Dreg >> uimm5 ; /* right shift (b) */
Dreg = Dreg << uimm5 ; /* left shift (b) */
A0 = A0 >> uimm5 ; /* right shift (b) */
A0 = A0 << uimm5 ; /* left shift (b) */
A1 = A1 << uimm5 ; /* left shift (b) */
A1 = A1 >> uimm5 ; /* right shift (b) */

Data Shift, Registered Shift Magnitude

Dreg >>= Dreg ; /* right shift (a) */
Dreg <<= Dreg ; /* left shift (a) */
Dreg_lo_hi = LSHIFT Dreg_lo_hi BY Dreg_lo ; /* (b) */
Dreg = LSHIFT Dreg BY Dreg_lo ; /* (b) */
A0 = LSHIFT A0 BY Dreg_lo ; /* (b) */
A1 = LSHIFT A1 BY Dreg_lo ; /* (b) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Preg: P5–0

Instruction Length
The Logical Shift instruction logically shifts a register by a specified dis-
tance and direction.
Logical shifts discard any bits shifted out of the register and backfill
vacated bits with zeros.

Four versions of the Logical Shift instruction support pointer shifting.

The instruction does not implicitly modify the input src_pntr value. For
the P-register versions of this instruction, dest_pntr can be the same
P-register as src_pntr. Doing so explicitly modifies the source register.
The rest of this description applies to the data shift versions of this
instruction relating to D-registers and Accumulators.
The Logical Shift instruction supports 16-bit and 32-bit instruction
length.
• The “>>=” and “<<=” syntax instruction is 16 bits in length, allow-
ing for smaller code at the expense of flexibility.
• The “>>”, “<<”, and “LSHIFT” syntax instruction is 32 bits in
length, providing a separate source and destination register, alter-
native data sizes, and parallel issue with Load/Store instructions.
Both syntaxes support constant and registered shift magnitudes.
Table 9-2. Logical Shifts

Syntax Description
“>>=” The value in dest_reg is shifted by the number of places specified by

and “<<=” shift_magnitude. The data size is always 32 bits long. The entire 32 bits
of the shift_magnitude determine the shift value. Shift magnitudes
larger than 0x1F produce a 0x00000000 result.
“>>”, “<<”, The value in src_reg is shifted by the number of places specified in
and “LSHIFT” shift_magnitude, and the result is stored into dest_reg.
The LSHIFT versions can shift 32-bit Dreg and 40-bit Accumulator
registers by up to –32 through +31 places.
For the LSHIFT version, the sign of the shift magnitude determines the
• Positive shift magnitudes produce Left shifts.
• Negative shift magnitudes produce Right shifts.

The dest_reg and src_reg can be a 16-, 32-, or 40-bit register.

For the LSHIFT instruction, the shift magnitude is the lower 6 bits of the
Dreg_lo, sign extended. The Dreg >>= Dreg and Dreg <<= Dreg instruc-
tions use the entire 32 bits of magnitude.
The D-register versions of this instruction shift 16 or 32 bits for half-word
and word registers, respectively. The Accumulator versions shift all 40 bits
of those registers.
Forty-bit Accumulator values can be shifted by up to –32 to +31 bit
places.
Shift magnitudes that exceed the size of the destination register produce
all zeros in the result. For example, shifting a 16-bit register value by 20
bit places (a valid operation) produces 0x00000000.
A shift magnitude of zero performs no shift operation at all.
Flags Affected
The versions of this instruction that send results to a Dreg set flags as
follows.
• V is cleared.


flags as follows.
• AV0 is cleared.
flags as follows.
• AV1 is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
other instructions.

Example
p3 = p2 >> 1 ; /* pointer right shift by 1 */
p3 = p3 >> 2 ; /* pointer right shift by 2 */
p4 = p5 << 1 ; /* pointer left shift by 1 */
p0 = p1 << 2 ; /* pointer left shift by 2 */
r3 >>= 17 ; /* data right shift */
r3 <<= 17 ; /* data left shift */
r3.l = r0.l >> 4 ; /* data right shift, half-word register */
r3.l = r0.h >> 4 ; /* same as above; half-word register combi-
nations are arbitrary */
r3.h = r0.l << 12 ; /* data left shift, half-word register */
r3.h = r0.h << 14 ; /* same as above; half-word register com-
binations are arbitrary */
r3 = r6 >> 4 ; /* right shift, 32-bit word */
r3 = r6 << 4 ; /* left shift, 32-bit word */
a0 = a0 >> 7 ; /* Accumulator right shift */
a1 = a1 >> 25 ; /* Accumulator right shift */
a0 = a0 << 7 ; /* Accumulator left shift */
a1 = a1 << 14 ; /* Accumulator left shift */
r3 >>= r0 ; /* data right shift */
r3 <<= r1 ; /* data left shift */
r3.l = lshift r0.l by r2.l ; /* shift direction controlled by
sign of R2.L */
r3.h = lshift r0.l by r2.l ;
a0 = lshift a0 by r7.l ;
a1 = lshift a1 by r7.l ;
/* If r0.h = -64 (or 0xFFC0), then performing . . . */
r3.h = r0.h >> 4 ; /* . . . produces r3.h = 0x0FFC (or 4092),
losing the sign */
Also See
Arithmetic Shift, ROT (Rotate), Shift with Add, Vector Arithmetic Shift,
Vector Logical Shift

None

ROT (Rotate)
General Form
dest_reg = ROT src_reg BY rotate_magnitude
accumulator_new = ROT accumulator_old BY rotate_magnitude
Syntax
Constant Rotate Magnitude
Dreg = ROT Dreg BY imm6 ; /* (b) */
A0 = ROT A0 BY imm6 ; /* (b) */
A1 = ROT A1 BY imm6 ; /* (b) */
Registered Rotate Magnitude

Dreg = ROT Dreg BY Dreg_lo ; /* (b) */
A0 = ROT A0 BY Dreg_lo ; /* (b) */
A1 = ROT A1 BY Dreg_lo ; */ (b) */
Syntax Terminology
Dreg: R7–0
imm6: 6-bit signed field, with a range of –32 through +31
Instruction Length
The Rotate instruction rotates a register through the CC bit a specified dis-
tance and direction. The CC bit is in the rotate chain. Consequently, the
first value rotated into the register is the initial value of the CC bit.

Rotation shifts all the bits either right or left. Each bit that rotates out of
the register (the LSB for rotate right or the MSB for rotate left) is stored in
the CC bit, and the CC bit is stored into the bit vacated by the rotate on the
opposite end of the register.
If 31 0
D-register: 1010 1111 0000 0000 0000 0000 0001 1010
CC bit: N (“1” or “0”)
Rotate left 1 bit 31 0
D-register: 0101 1110 0000 0000 0000 0000 0011 010N
CC bit: 1
Rotate left 1 bit again 31 0
D-register: 1011 1100 0000 0000 0000 0000 0110 10N1
CC bit: 0
If 31 0
D-register: 1010 1111 0000 0000 0000 0000 0001 1010
CC bit: N (“1” or “0”)
Rotate right 1 bit 31 0
D-register: N101 0111 1000 0000 0000 0000 0000 1101
CC bit: 0
Rotate right 1 bit again 31 0
D-register: 0N10 1011 1100 0000 0000 0000 0000 0110
CC bit: 1

The sign of the rotate magnitude determines the direction of the rotation.
• Positive rotate magnitudes produce Left rotations.
• Negative rotate magnitudes produce Right rotations.
Valid rotate magnitudes are –32 through +31, zero included. The Rotate
instruction masks and ignores bits that are more significant than those
allowed. The distance is determined by the lower 6 bits (sign extended) of
the shift_magnitude.
Unlike shift operations, the Rotate instruction loses no bits of the source
register data. Instead, it rearranges them in a circular fashion. However,
the last bit rotated out of the register remains in the CC bit, and is not
returned to the register. Because rotates are performed all at once and not
one bit at a time, rotating one direction or another regardless of the rotate
magnitude produces no advantage. For instance, a rotate right by two bits
is no more efficient than a rotate left by 30 bits. Both methods produce
identical results in identical execution time.
The D-register versions of this instruction rotate all 32 bits. The Accumu-
lator versions rotate all 40 bits of those registers.

Flags Affected
The following flags are affected by the Rotate instruction.
• CC contains the latest value shifted into it.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r4 = rot r1 by 8 ; /* rotate left */
r4 = rot r1 by -5 ; /* rotate right */
a0 = rot a0 by 22 ; /* rotate Accumulator left */
a1 = rot a1 by -31 ; /* rotate Accumulator right */
r4 = rot r1 by r2.l ;
a0 = rot a0 by r3.l ;
a1 = rot a1 by r7.l ;
Also See
Arithmetic Shift, Logical Shift

None


10 ARITHMETIC OPERATIONS
Instruction Summary
• “ABS” on page 10-3
• “Add” on page 10-6
• “Add/Subtract – Prescale Down” on page 10-10
• “Add/Subtract – Prescale Up” on page 10-13
• “Add Immediate” on page 10-16
• “DIVS, DIVQ (Divide Primitive)” on page 10-19
• “EXPADJ” on page 10-27
• “MAX” on page 10-31
• “MIN” on page 10-34
• “Modify – Decrement” on page 10-37
• “Modify – Increment” on page 10-40
• “Multiply 16-Bit Operands” on page 10-46
• “Multiply 32-Bit Operands” on page 10-54
• “Multiply and Multiply-Accumulate to Accumulator” on
page 10-56
• “Multiply and Multiply-Accumulate to Half-Register” on
page 10-61

• “Multiply and Multiply-Accumulate to Data Register” on

page 10-70
• “Negate (Two’s Complement)” on page 10-76
• “RND (Round to Half-Word)” on page 10-80
• “Saturate” on page 10-83
• “SIGNBITS” on page 10-86
• “Subtract” on page 10-89
• “Subtract Immediate” on page 10-93
This chapter discusses the instructions that specify arithmetic operations.
Users can take advantage of these instructions to add, subtract, divide, and
multiply, as well as to calculate and store absolute values, detect expo-
nents, round, saturate, and return the number of sign bits.

Arithmetic Operations
ABS
General Form
dest_reg = ABS src_reg
Syntax
A0 = ABS A0 ; /* (b) */
A0 = ABS A1 ; /* (b) */
A1 = ABS A0 ; /* (b) */
A1 = ABS A1 ; /* (b) */
A1 = ABS A1, A0 = ABS A0 ; /* (b) */
Dreg = ABS Dreg ; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Absolute Value instruction calculates the absolute value of a 32-bit
register and stores it into a 32-bit dest_reg according to the following
rules.
• If the input value is positive or zero, copy it unmodified to the
destination.
• If the input value is negative, subtract it from zero and store the
result in the destination.
The ABS operation can also be performed on both Accumulators by a sin-
gle instruction.

Flags Affected
• AN is cleared.
• Vis set if the maximum negative value is saturated to the maximum
positive value and the dest_reg is a Dreg; cleared if no saturation.
• AV0 is set if result overflows and the dest_reg is A0; cleared if no
overflow.
• AV1 is set if result overflows and the dest_reg is A1; cleared if no
overflow.

ASTAT
on page A-2.
Required Mode
User & Supervisor

Parallel Issue
Example
a0 = abs a0 ;
a0 = abs a1 ;
a1 = abs a0 ;
a1 = abs a1 ;
a1 = abs a1, a0=abs a0 ;
r3 = abs r1 ;
Also See
Vector ABS
None

Add
General Form
dest_reg = src_reg_1 + src_reg_2
Syntax
Pointer Registers — 32-Bit Operands, 32-Bit Result
Preg = Preg + Preg ; /* (a) */
Data Registers — 32-Bit Operands, 32-bit Result

Dreg = Dreg + Dreg ; /* no saturation support but shorter
instruction length (a) */
Dreg = Dreg + Dreg (sat_flag) ; /* saturation optionally sup-
ported, but at the cost of longer instruction length (b) */
Data Registers — 16-Bit Operands, 16-Bit Result

Dreg_lo_hi = Dreg_lo_hi + Dreg_lo_hi (sat_flag) ; /* (b) */
Syntax Terminology
Dreg: R7–0
sat_flag: nonoptional saturation flag, (S) or (NS)
Instruction Length

The Add instruction adds two source values and places the result in a des-
tination register.
There are two ways to specify addition on 32-bit data in D-registers:
• One does not support saturation (16-bit instruction length)
• The other supports optional saturation (32-bit instruction length)
The shorter 16-bit instruction takes up less memory space. The larger
32-bit instruction can sometimes save execution time because it can be
issued in parallel with certain other instructions. See “Parallel Issue”.
The D-register version that accepts 16-bit half-word operands stores the
result in a half-word data register. This version accepts any combination
of upper and lower half-register operands, and places the results in the
upper or lower half of the destination register at the user’s discretion.
All versions that manipulate 16-bit data are 32 bits long.
Options
In the syntax, where sat_flag appears, substitute one of the following
values.
(S) – saturate the result
(NS) – no saturation

Flags Affected
D-register versions of this instruction set flags as follows.
• AC0 is set if the operation generates a carry; cleared if no carry.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
other instructions.

Example
r5 = r2 + r1 ; /* 16-bit instruction length add, no
saturation */
r5 = r2 + r1(ns) ; /* same result as above, but 32-bit
instruction length */
r5 = r2 + r1(s) ; /* saturate the result */
p5 = p3 + p0 ;
/* If r0.l = 0x7000 and r7.l = 0x2000, then . . . */
r4.l = r0.l + r7.l (ns) ; /* . . . produces r4.l = 0x9000,
because no saturation is enforced */
/* If r0.l = 0x7000 and r7.h = 0x2000, then . . . */
r4.l = r0.l + r7.h (s) ; /* . . . produces r4.l = 0x7FFF, satu-
rated to the maximum positive value */
r0.l = r2.h + r4.l(ns) ;
r1.l = r3.h + r7.h(ns) ;
r4.h = r0.l + r7.l (ns) ;
r4.h = r0.l + r7.h (ns) ;
r0.h = r2.h + r4.l(s) ; /* saturate the result */
r1.h = r3.h + r7.h(ns) ;
Also See
Modify – Increment, Add with Shift, Shift with Add, Vector Add /
Subtract
None

Add/Subtract – Prescale Down
General Form
dest_reg = src_reg_0 + src_reg_1 (RND20)
dest_reg = src_reg_0 - src_reg_1 (RND20)
Syntax
Dreg_lo_hi = Dreg + Dreg (RND20) ; // (b)
Dreg_lo_hi = Dreg - Dreg (RND20) ; // (b)
Syntax Terminology
Dreg: R7–0
Instruction Length
The Add/Subtract -- Prescale Down instruction combines two 32-bit val-
ues to produce a 16-bit result as follows:
• Prescale down both input operand values by arithmetically shifting
them four places to the right
• Add or subtract the operands, depending on the instruction version
used
• Round the upper 16 bits of the result
• Extract the upper 16 bits to the dest_reg

The instruction supports only biased rounding. The RND_MOD bit in the
ASTAT register has no bearing on the rounding behavior of this instruction.

ing behavior.
Flags Affected
The following flags are affected by this instruction:
• V is cleared.
All other flags are unaffected.
Required Mode
User & Supervisor
Parallel Issue
Example
r1.l = r6+r7(rnd20) ;
r1.l = r6-r7(rnd20) ;
r1.h = r6+r7(rnd20) ;
r1.h = r6-r7(rnd20) ;
Also See
Add/Subtract – Prescale Up, RND (Round to Half-Word), Add

Typically, use the Add/Subtract – Prescale Down instruction to provide
an IEEE 1180–compliant 2D 8x8 inverse discrete cosine transform.

Add/Subtract – Prescale Up
General Form
dest_reg = src_reg_0 + src_reg_1 (RND12)
dest_reg = src_reg_0 - src_reg_1 (RND12)
Syntax
Dreg_lo_hi = Dreg + Dreg (RND12) ; // (b)
Dreg_lo_hi = Dreg - Dreg (RND12) ; // (b)
Syntax Terminology
Dreg: R7–0
Instruction Length
The Add/Subtract – Prescale Up instruction combines two 32-bit values
to produce a 16-bit result as follows:
• Prescale up both input operand values by shifting them four places
to the left
• Add or subtract the operands, depending on the instruction version
used
• Round and saturate the upper 16 bits of the result
• Extract the upper 16 bits to the dest_reg

The instruction supports only biased rounding. The RND_MOD bit in the
ASTAT register has no bearing on the rounding behavior of this instruction.

ing behavior.
Flags Affected
The following flags are affected by this instruction:
• V is set if result saturates; cleared if no saturation.
All other flags are unaffected.
Required Mode
User & Supervisor
Parallel Issue
Example
r1.l = r6+r7(rnd12) ;
r1.l = r6-r7(rnd12) ;
r1.h = r6+r7(rnd12) ;
r1.h = r6-r7(rnd12) ;

Also See
RND (Round to Half-Word), Add/Subtract – Prescale Down, Add
Typically, use the Add/Subtract – Prescale Up instruction to provide an
IEEE 1180–compliant 2D 8x8 inverse discrete cosine transform.

Add Immediate
General Form
register += constant
Syntax
Dreg += imm7 ; /* Dreg = Dreg + constant (a) */
Preg += imm7 ; /* Preg = Preg + constant (a) */
Ireg += 2 ; /* increment Ireg by 2, half-word address pointer
increment (a) */
Ireg += 4 ; /* word address pointer increment (a) */
Syntax Terminology
Dreg: R7–0
Ireg: I3–0
imm7: 7-bit signed field, with the range of –64 through +63
Instruction Length
The Add Immediate instruction adds a constant value to a register without
saturation.
L ToImmediate
subtract immediate values from I-registers, use the Subtract
instruction.
The instruction versions that explicitly modify Ireg support



Flags Affected
D-register versions of this instruction set flags as follows.

ASTAT
on page A-2.
The P-register and I-register versions of this instruction do not affect any
flags.

Required Mode
User & Supervisor
Parallel Issue
The Index Register versions of this instruction can be issued in parallel
with specific other instructions. For details, see “Issuing Parallel Instruc-
tions” on page 15-1.
The Data Register and Pointer Register versions of this instruction cannot
be issued in parallel with other instructions.
Example
r0 += 40 ;
p5 += -4 ; /* decrement by adding a negative value */
i0 += 2 ;
i1 += 4 ;
Also See
Subtract Immediate
None

DIVS, DIVQ (Divide Primitive)
General Form
DIVS ( dividend_register, divisor_register )
DIVQ ( dividend_register, divisor_register )
Syntax
DIVS ( Dreg, Dreg ) ; /* Initialize for DIVQ. Set the AQ flag
based on the signs of the 32-bit dividend and the 16-bit divisor.
Left shift the dividend one bit. Copy AQ into the dividend LSB.
(a) */
DIVQ ( Dreg, Dreg ) ; /* Based on AQ flag, either add or sub-
tract the divisor from the dividend. Then set the AQ flag based
on the MSBs of the 32-bit dividend and the 16-bit divisor. Left
shift the dividend one bit. Copy the logical inverse of AQ into
the dividend LSB. (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Divide Primitive instruction versions are the foundation elements of a
nonrestoring conditional add-subtract division algorithm. See “Example”
on page 10-25 for such a routine.
The dividend (numerator) is a 32-bit value. The divisor (denominator) is
a 16-bit value in the lower half of divisor_register. The high-order
half-word of divisor_register is ignored entirely.

The division can either be signed or unsigned, but the dividend and divi-
sor must both be of the same type. The divisor cannot be negative. A
signed division operation, where the dividend may be negative, begins the
sequence with the DIVS (“divide-sign”) instruction, followed by repeated
execution of the DIVQ (“divide-quotient”) instruction. An unsigned divi-
sion omits the DIVS instruction. In that case, the user must manually clear
the AQ flag of the ASTAT register before issuing the DIVQ instructions.
Up to 16 bits of signed quotient resolution can be calculated by issuing
DIVS once, then repeating the DIVQ instruction 15 times. A 16-bit
unsigned quotient is calculated by omitting DIVS, clearing the AQ flag, then
issuing 16 DIVQ instructions.
Less quotient resolution is produced by executing fewer DIVQ iterations.
The result of each successive addition or subtraction appears in
dividend_register, aligned and ready for the next addition or subtraction
step. The contents of divisor_register are not modified by this
instruction.
The final quotient appears in the low-order half-word of
dividend_register at the end of the successive add/subtract sequence.
DIVS computes the sign bit of the quotient based on the signs of the divi-
dend and divisor. DIVS initializes the AQ flag based on that sign, and
initializes the dividend for the first addition or subtraction. DIVS performs
no addition or subtraction.
DIVQ either adds (dividend + divisor) or subtracts (dividend – divisor)
based on the AQ flag, then reinitializes the AQ flag and dividend for the next
iteration. If AQ is 1, addition is performed; if AQ is 0, subtraction is
performed.
See “Flags Affected” for the conditions that set and clear the AQ flag.

Both instruction versions align the dividend for the next iteration by left
shifting the dividend one bit to the left (without carry). This left shift
accomplishes the same function as aligning the divisor one bit to the right,
such as one would do in manual binary division.
The format of the quotient for any numeric representation can be deter-
mined by the format of the dividend and divisor. Let:
• NL represent the number of bits to the left of the binal point of the
dividend, and
• NR represent the number of bits to the right of the binal point of
the dividend (numerator);
• DL represent the number of bits to the left of the binal point of the
divisor, and
• DR represent the number of bits to the right of the binal point of
the divisor (denominator).
Then the quotient has NL – DL + 1 bits to the left of the binal point and
NR – DR – 1 bits to the right of the binal point. See the following
example.
Dividend (numerator) BBBB B . BBB BBBB BBBB BBBB BBBB BBBB BBBB
NL bits NR bits
Divisor (denominator) BB . BB BBBB BBBB BBBB

DL bits DR bits
Quotient BBBB . BBBB BBBB BBBB
NL - DL +1 NR - DR - 1
(5 - 2 + 1) (27 - 14 - 1)
4.12 format
Some format manipulation may be necessary to guarantee the validity of

the quotient. For example, if both operands are signed and fully fractional
(dividend in 1.31 format and divisor in 1.15 format), the result is fully

fractional (in 1.15 format) and therefore the upper 16 bits of the dividend
must have a smaller magnitude than the divisor to avoid a quotient over-
flow beyond 16 bits. If an overflow occurs, AV0 is set. User software is able
to detect the overflow, rescale the operand, and repeat the division.
Dividing two integers (32.0 dividend by a 16.0 divisor) results in an
invalid quotient format because the result will not fit in a 16-bit register.
To divide two integers (dividend in 32.0 format and divisor in 16.0 for-
mat) and produce an integer quotient (in 16.0 format), one must shift the
dividend one bit to the left (into 31.1 format) before dividing. This
requirement to shift left limits the usable dividend range to 31 bits. Viola-
tions of this range produce an invalid result of the division operation.
The algorithm overflows if the result cannot be represented in the format
of the quotient as calculated above, or when the divisor is zero or less than
the upper 16 bits of the dividend in magnitude (which is tantamount to
multiplication).

Error Conditions
Two special cases can produce invalid or inaccurate results. Software can
trap and correct both cases.
1. The Divide Primitive instructions do not support signed division
by a negative divisor. Attempts to divide by a negative divisor result
in a quotient that is, in most cases, one LSB less than the correct
value. If division by a negative divisor is required, follow the steps
below.
• Before performing the division, save the sign of the divisor
in a scratch register.
• Calculate the absolute value of the divisor and use that value
as the divisor operand in the Divide Primitive instructions.
• After the divide sequence concludes, multiply the resulting
quotient by the original divisor sign.
• The quotient then has the correct magnitude and sign.
2. The Divide Primitive instructions do not support unsigned divi-
sion by a divisor greater than 0x7FFF. If such divisions are
necessary, prescale both operands by shifting the dividend and divi-
sor one bit to the right prior to division. The resulting quotient
will be correctly aligned.

Of course, prescaling the operands decreases their resolution, and

may introduce one LSB of error in the quotient. Such error can be
detected and corrected by the following steps.
• Save the original (unscaled) dividend and divisor in scratch
registers.
• Prescale both operands as described and perform the divi-
sion as usual.
• Multiply the resulting quotient by the unscaled divisor. Do
not corrupt the quotient by the multiplication step.
• Subtract the product from the unscaled dividend. This step
produces an error value.
• Compare the error value to the unscaled divisor.
• If error > divisor, add one LSB to the quotient.
• If error < divisor, subtract one LSB from the
quotient.
• If error = divisor, do nothing.
Tested examples of these solutions are planned to be added in a later edi-
tion of this document.

Flags Affected
• AQ equals dividend_MSB Exclusive-OR divisor_MSB where dividend
is a 32-bit value and divisor is a 16-bit value.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
/* Evaluate given a signed integer dividend and divisor */
p0 = 15 ; /* Evaluate the quotient to 16 bits. */
r0 = 70 ; /* Dividend, or numerator */
r1 = 5 ; /* Divisor, or denominator */
r0 <<= 1 ; /* Left shift dividend by 1 needed for integer divi-
sion */
divs (r0, r1) ; /* Evaluate quotient MSB. Initialize AQ flag
and dividend for the DIVQ loop. */
loop .div_prim lc0=p0 ; /* Evaluate DIVQ p0=15 times. */
loop_begin .div_prim ;
divq (r0, r1) ;
loop_end .div_prim ;

r0 = r0.l (x) ; /* Sign extend the 16-bit quotient to 32bits.

*/
/* r0 contains the quotient (70/5 = 14). */
Also See
LSETUP, LOOP, Multiply 32-Bit Operands
None

EXPADJ
General Form
dest_reg = EXPADJ ( sample_register, exponent_register )
Syntax
Dreg_lo = EXPADJ ( Dreg, Dreg_lo ) ; /* 32-bit sample (b) */
Dreg_lo = EXPADJ ( Dreg_lo_hi, Dreg_lo ) ; /* one 16-bit sam-
ple (b) */
Dreg_lo = EXPADJ ( Dreg, Dreg_lo ) (V) ; /* two 16-bit samples
(b) */
Syntax Terminology
Dreg_lo: R7–0.L
Dreg: R7–0
Instruction Length
The Exponent Detection instruction identifies the largest magnitude of
two or three fractional numbers based on their exponents. It compares the
magnitude of one or two sample values to a reference exponent and
returns the smallest of the exponents.
The exponent is the number of sign bits minus one. In other words, the
exponent is the number of redundant sign bits in a signed number.

Exponents are unsigned integers. The Exponent Detection instruction

accommodates the two special cases (0 and –1) and always returns the
smallest exponent for each case.
The reference exponent and destination exponent are 16-bit half-word
unsigned values. The sample number can be either a word or half-word.
The Exponent Detection instruction does not implicitly modify input val-
ues. The dest_reg and exponent_register can be the same D-register.
Doing this explicitly modifies the exponent_register.
The valid range of exponents is 0 through 31, with 31 representing the
smallest 32-bit number magnitude and 15 representing the smallest 16-bit
number magnitude.
Exponent Detection supports three types of samples—one 32-bit sample,
one 16-bit sample (either upper-half or lower-half word), and two 16-bit
samples that occupy the upper-half and lower-half words of a single 32-bit
register.
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
r5.l = expadj (r4, r2.l) ;
• Assume R4 = 0x0000 0052 and R2.L = 12. Then R5.L becomes 12.
• Assume R4 = 0xFFFF 0052 and R2.L = 12. Then R5.L becomes 12.
• Assume R4 = 0x0000 0052 and R2.L = 27. Then R5.L becomes 24.
• Assume R4 = 0xF000 0052 and R2.L = 27. Then R5.L becomes 3.
r5.l = expadj (r4.l, r2.l) ;
• Assume R4.L = 0x0765 and R2.L = 12. Then R5.L becomes 4.

• Assume R4.L = 0xC765 and R2.L = 12. Then R5.L becomes 1.
r5.l = expadj (r4.h, r2.l) ;
• Assume R4.H = 0x0765 and R2.L = 12. Then R5.L becomes 4.

• Assume R4.H = 0xC765 and R2.L = 12. Then R5.L becomes 1.
r5.l = expadj (r4, r2.l)(v) ;
• Assume R4.L = 0x0765, R4.H = 0xFF74 and R2.L = 12. Then R5.L
becomes 4.
• Assume R4.L = 0x0765, R4.H = 0xE722 and R2.L = 12. Then R5.L
becomes 2.
Also See
SIGNBITS

EXPADJ detects the exponent of the largest magnitude number in an array.
The detected value may then be used to normalize the array on a subse-
quent pass with a shift operation. Typically, use this feature to implement
block floating-point capabilities.

MAX
General Form
dest_reg = MAX ( src_reg_0, src_reg_1 )
Syntax
Dreg = MAX ( Dreg , Dreg ) ; /* 32-bit operands (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Maximum instruction returns the maximum, or most positive, value
of the source registers. The operation subtracts src_reg_1 from src_reg_0
and selects the output based on the signs of the input values and the arith-
metic flags.
The Maximum instruction does not implicitly modify input values. The
dest_reg can be the same D-register as one of the source registers. Doing
this explicitly modifies the source register.
Flags Affected

• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r5 = max (r2, r3) ;
• Assume R2 = 0x00000000 and R3 = 0x0000000F, then R5 =

0x0000000F.
0x0000000F.
• Assume R2 = 0xFFFFFFFF and R3 = 0x0000000F, then R5 =
0x0000000F.
Also See
MIN, Vector MAX, Vector MIN, VIT_MAX (Compare-Select)

None

MIN
General Form
dest_reg = MIN ( src_reg_0, src_reg_1 )
Syntax
Dreg = MIN ( Dreg , Dreg ) ; /* 32-bit operands (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Minimum instruction returns the minimum value of the source regis-
ters to the dest_reg. (The minimum value of the source registers is the
value closest to – ∞.) The operation subtracts src_reg_1 from src_reg_0
and selects the output based on the signs of the input values and the arith-
metic flags.
The Minimum instruction does not implicitly modify input values. The
this explicitly modifies the source register.
Flags Affected

• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r5 = min (r2, r3) ;

0x00000000.
0x80000000.
• Assume R2 = 0xFFFFFFFF and R3 = 0x0000000F, then R5 =
0xFFFFFFFF.
Also See
MAX, Vector MAX, Vector MIN

None

Modify – Decrement
General Form
dest_reg -= src_reg
Syntax
40-Bit Accumulators
A0 -= A1 ; /* dest_reg_new = dest_reg_old - src_reg, saturate
the result at 40 bits (b) */
A0 -= A1 (W32) ; /* dest_reg_new = dest_reg_old - src_reg, dec-
rement and saturate the result at 32 bits, sign extended (b) */
32-Bit Registers
Preg -= Preg ; /* dest_reg_new = dest_reg_old - src_reg (a) */
Ireg -= Mreg ; /* dest_reg_new = dest_reg_old - src_reg (a) */
Syntax Terminology
Ireg: I3–0
Mreg: M3–0
Instruction Length
The Modify – Decrement instruction decrements a register by a
user-defined quantity.

L The instruction versions that explicitly modify support Ireg

Flags Affected
The Accumulator versions of this instruction affect the flags as follows.
• AV0 is set if result saturates; cleared if no saturation.

ASTAT
on page A-2.
The P-register and I-register versions do not affect any flags.

Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
a0 -= a1 ;
a0 -= a1 (w32) ;
p3 -= p0 ;
i1 -= m2 ;
Also See
Modify – Increment, Subtract, Shift with Add
Typically, use the Index Register and Pointer Register versions of the
Modify – Decrement instruction to decrement indirect address pointers
for load or store operations.

Modify – Increment
General Form
dest_reg += src_reg
dest_reg = ( src_reg_0 += src_reg_1 )
Syntax
40-Bit Accumulators
A0 += A1 ; /* dest_reg_new = dest_reg_old + src_reg, saturate
the result at 40 bits (b) */
A0 += A1 (W32) ; /* dest_reg_new = dest_reg_old + src_reg,
signed saturate the result at 32 bits, sign extended (b) */
32-Bit Registers
Preg += Preg (BREV) ; /* dest_reg_new = dest_reg_old +
src_reg, bit reversed carry, only (a) */
Ireg += Mreg (opt_brev) ; /* dest_reg_new = dest_reg_old +
src_reg, optional bit reverse (a) */
Dreg = ( A0 += A1 ) ; /* increment 40-bit A0 by A1 with satura-
tion at 40 bits, then extract the result into a 32-bit register
with saturation at 32 bits (b) */
16-Bit Half-Word Data Registers

Dreg_lo_hi = ( A0 += A1 ) ; /* Increment 40-bit A0 by A1 with
saturation at 40 bits, then extract the result into a half regis-
ter. The extraction step involves first rounding the 40-bit

result at bit 16 (according to the RND_MOD bit in the ASTAT reg-

ister), then saturating at 32 bits and moving bits 31:16 into the
half register. (b) */
Syntax Terminology
Dreg: R7–0
Ireg: I3–0
Mreg: M3–0
opt_brev: optional bit reverse syntax; replace with (brev)

Instruction Length
The Modify – Increment instruction increments a register by a
user-defined quantity. In some versions, the instruction copies the result
into a third register.
The 16-bit Half-Word Data Register version increments the 40-bit A0 by
A1 with saturation at 40 bits, then extracts the result into a half register.
The extraction step involves first rounding the 40-bit result at bit 16
(according to the RND_MOD bit in the ASTAT register), then saturating at 32
bits and moving bits 31–16 into the half register.


ing behavior.

Ireg
Options
(BREV)–bit reverse carry adder. When specified, the carry bit is propagated
from left to right, as shown in Figure 10-1, instead of right to left.
When bit reversal is used on the Index Register version of this instruction,
circular buffering is disabled to support operand addressing for FFT,
DCT and DFT algorithms. The Pointer Register version does not support
circular buffering in any case.
Table 10-1. Bit Addition Flow for the Bit Reverse (BREV) Case
an a2 a1 a0
| cn | c2 | c1 |
+ + + + c0
| | | |
bn b2 b1 b0

Flags Affected
The versions of the Modify – Increment instruction that store the results
in an Accumulator affect flags as follows.
• AZ is set if Accumulator result is zero; cleared if nonzero.
• AN is set if Accumulator result is negative; cleared if non-negative.
• V is set if result saturates and the dest_reg is a Dreg; cleared if no
saturation.
• AV0 is set if result saturates and the dest_reg is A0; cleared if no
saturation.
The versions of the Modify – Increment instruction that store the results
in a Data Register affect flags as follows.
• AZ is set if Data Register result is zero; cleared if nonzero.
• AN is set if Data Register result is negative; cleared if non-negative.
• V is set if result saturates and the dest_reg is a Dreg; cleared if no
saturation.
saturation.



ASTAT
on page A-2.
The Pointer Register, Index Register, and Modify Register versions of the
instruction do not affect the flags.
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
a0 += a1 ;
a0 += a1 (w32) ;
p3 += p0 (brev) ;
i1 += m1 ;
i0 += m0 (brev) ; /* optional carry bit reverse mode */
r5 = (a0 += a1) ;
r2.l = (a0 += a1) ;
r5.h = (a0 += a1) ;

Also See
Modify – Decrement, Add, Shift with Add
Typically, use the Index Register and Pointer Register versions of the
Modify – Increment instruction to increment indirect address pointers for
load or store operations.

Multiply 16-Bit Operands
General Form
dest_reg = src_reg_0 * src_reg_1 (opt_mode)
Syntax
Multiply-And-Accumulate Unit 0 (MAC0)
Dreg_lo = Dreg_lo_hi * Dreg_lo_hi (opt_mode_1) ; /* 16-bit
result into the destination lower half-word register (b) */
Dreg_even = Dreg_lo_hi * Dreg_lo_hi (opt_mode_2) ; /* 32-bit
result (b) */

Dreg_hi = Dreg_lo_hi * Dreg_lo_hi (opt_mode_1) ; /* 16-bit
result into the destination upper half-word register (b) */
Dreg_odd = Dreg_lo_hi * Dreg_lo_hi (opt_mode_2) ; /* 32-bit
result (b) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Dreg_hi: R7–0.H
opt_mode_1: Optionally (FU), (IS), (IU), (T), (TFU), (S2RND), (ISS2) or

(IH). Optionally, (M) can be used with MAC1 versions either alone or
with any of these other options. When used together, the option flags
must be enclosed in one set of parentheses and separated by a comma.
Example: (M, IS)

opt_mode_2: Optionally (FU), (IS), or (ISS2). Optionally, (M) can be

used with MAC1 versions either alone or with any of these other options.
When used together, the option flags must be enclosed in one set of
parenthesis and separated by a comma. Example: (M, IS)
Instruction Length
The Multiply 16-Bit Operands instruction multiplies the two 16-bit oper-
ands and stores the result directly into the destination register with
saturation.
The instruction is like the Multiply-Accumulate instructions, except that
Multiply 16-Bit Operands does not affect the Accumulators.
Operations performed by the Multiply-and-Accumulate Unit 0 (MAC0)
portion of the architecture load their 16-bit results into the lower half of
the destination data register; 32-bit results go into an even numbered
Dreg. Operations performed by MAC1 load their results into the upper
half of the destination data register or an odd numbered Dreg.
In 32-bit result syntax, the MAC performing the operation will be deter-
mined by the destination Dreg. Even-numbered Dregs (R6, R4, R2, R0)
invoke MAC0. Odd-numbered Dregs (R7, R5, R3, R1) invoke MAC1.
Therefore, 32-bit result operations using the (M) option can only be per-
formed on odd-numbered Dreg destinations.
In 16-bit result syntax, the MAC performing the operation will be deter-
mined by the destination Dreg half. Low-half Dregs (R7–0.L) invoke
MAC0. High-half Dregs (R7–0.H) invoke MAC1. Therefore, 16-bit result
operations using the (M) option can only be performed on high-half Dreg
destinations.

The versions of this instruction that produce 16-bit results are affected by
the RND_MOD bit in the ASTAT register when they copy the results into the
16-bit destination register. RND_MOD determines whether biased or unbi-
ased rounding is used. RND_MOD controls rounding for all versions of this
instruction that produce 16-bit results except the (IS), (IU) and (ISS2)
options.
ing behavior.
The versions of this instruction that produce 32-bit results do not perform
rounding and are not affected by the RND_MOD bit in the ASTAT register.
Options
The Multiply 16-Bit Operands instruction supports the following
options. Saturation is supported for every option.
In fractional mode, the product of the smallest representable fraction
times itself (for example, 0x8000 times 0x8000) is saturated to the maxi-
mum representable positive fraction (0x7FFF).

Table 10-2. Multiply 16-Bit Operands Options

Option Description for Description for
Register Half Destination 32-Bit Register Destination
Default Signed fraction. Multiply 1.15 * 1.15 to Signed fraction. Multiply 1.15 * 1.15 to
produce 1.31 results after left-shift cor- produce 1.31 results after left-shift correc-
rection. Round 1.31 format value at bit tion. Saturate results between minimum -1
16. (RND_MOD bit in the ASTAT and maximum 1-2-31.
register controls the rounding.) Satu- The resulting hexadecimal range is mini-
rate the result to 1.15 precision in desti- mum 0x8000 0000 through maximum
nation register half. Result is between 0x7FFF FFFF.
minimum -1 and maximum 1-2-15 (or,
expressed in hex, between minimum
0x8000 and maximum 0x7FFF).
(FU) Unsigned fraction. Multiply 0.16 * Unsigned fraction. Multiply 0.16 * 0.16 to
0.16 to produce 0.32 results. No shift produce 0.32 results. No shift correction.
correction. Round 0.32 format value at Saturate results between minimum 0 and
bit 16. (RND_MOD bit in the ASTAT maximum 1-2-32.
register controls the rounding.) Satu- Unsigned integer. Multiply 16.0 * 16.0 to
rate the result to 0.16 precision in desti- produce 32.0 results. No shift correction.
nation register half. Result is between Saturate results between minimum 0 and
minimum 0 and maximum 1-2-16 (or, maximum 232-1.
expressed in hex, between minimum In either case, the resulting hexadecimal
0x0000 and maximum 0xFFFF). range is minimum 0x0000 0000 through
maximum 0xFFFF FFFF.
(IS) Signed integer. Multiply 16.0 * 16.0 to Signed integer. Multiply 16.0 * 16.0 to
produce 32.0 results. No shift correc- produce 32.0 results. No shift correction.
tion. Extract the lower 16 bits. Saturate Saturate integer results between minimum
for 16.0 precision in destination register -231 and maximum 231-1.
half. Result is between minimum -215
and maximum 215-1 (or, expressed in
hex, between minimum 0x8000 and
maximum 0x7FFF).
(IU) Unsigned integer. Multiply 16.0 * 16.0 Not applicable. Use (IS).
to produce 32.0 results. No shift correc-
tion. Extract the lower 16 bits. Saturate
for 16.0 precision in destination register
half. Result is between minimum 0 and
maximum 216-1 (or, expressed in hex,
between minimum 0x0000 and maxi-
mum 0xFFFF).

Table 10-2. Multiply 16-Bit Operands Options (Cont’d)

(T) Signed fraction with truncation. Trun- Not applicable. Truncation is meaningless
cate Accumulator 9.31 format value at for 32-bit register destinations.
bit 16. (Perform no rounding.) Satu-
rate the result to 1.15 precision in desti-
nation register half. Result is between
minimum -1 and maximum 1-2-15 (or,
(TFU) Unsigned fraction with truncation. Not applicable.

Multiply 1.15 * 1.15 to produce 1.31
results after left-shift correction. (Iden-
tical to Default.) Truncate 1.32 format
value at bit 16. (Perform no rounding.)
Saturate the result to 0.16 precision in
destination register half. Result is
between minimum 0 and maximum
1-2-16 (or, expressed in hex, between
minimum 0x0000 and maximum
0xFFFF).
(S2RND Signed fraction with scaling and round- Not applicable.

) ing. Multiply 1.15 * 1.15 to produce
1.31 results after left-shift correction.
(Identical to Default.) Shift the result
one place to the left (multiply x 2).
Round 1.31 format value at bit 16.
(RND_MOD bit in the ASTAT register
controls the rounding.) Saturate the
result to 1.15 precision in destination
register half. Result is between mini-
mum -1 and maximum 1-2-15 (or,

Table 10-2. Multiply 16-Bit Operands Options (Cont’d)

(ISS2) Signed integer with scaling. Multiply Signed integer with scaling. Multiply 16.0
16.0 * 16.0 to produce 32.0 results. No * 16.0 to produce 32.0 results. No shift
shift correction. Extract the lower 16 correction. Shift the results one place to
bits. Shift them one place to the left the left (multiply x 2). Saturate result to
(multiply x 2). Saturate the result for 32.0 format. Copy to destination regis-
16.0 format in destination register half. ter. Results range between minimum -1
Result is between minimum -215 and and maximum 231-1.
maximum 215-1 (or, expressed in hex, The resulting hexadecimal range is mini-
between minimum 0x8000 and maximum 0x8000 0000 through maximum
mum 0x7FFF). 0x7FFF FFFF.
(IH) Signed integer, high word extract. Mul- Not applicable.

tiply 16.0 * 16.0 to produce 32.0
results. No shift correction. Round 32.0
format value at bit 16. (RND_MOD
bit in the ASTAT register controls the
rounding.) Saturate to 32.0 result.
Extract the upper 16 bits of that value
to the destination register half. Result is
between minimum -215 and maximum
215-1 (or, expressed in hex, between
minimum 0x8000 and maximum
0x7FFF).
(M) Mixed mode multiply (valid only for MAC1). When issued in a fraction mode
instruction (with Default, FU, T, TFU, or S2RND mode), multiply 1.15 * 0.16 to
produce 1.31 results.
When issued in an integer mode instruction (with IS, ISS2, or IH mode), multiply
16.0 * 16.0 (signed * unsigned) to produce 32.0 results.
No shift correction in either case. Src_reg_0 is the signed operand and Src_reg_1 is
the unsigned operand.
All other operations proceed according to the other mode flag or Default.

Flags Affected

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r3.l=r3.h*r2.h ; /* MAC0. Both operands are signed
fractions. */
r3.h=r6.h*r4.l (fu) ; /* MAC1. Both operands are unsigned frac-
tions. */
r6=r3.h*r4.h ; /* MAC0. Signed fraction operands, results saved
as 32 bits. */

Also See
Multiply 32-Bit Operands, Multiply and Multiply-Accumulate to Accu-
mulator, Multiply and Multiply-Accumulate to Half-Register, Multiply
and Multiply-Accumulate to Data Register, Vector Multiply, Vector Mul-
tiply and Multiply-Accumulate
None

General Form
dest_reg *= multiplier_register
Syntax
Dreg *= Dreg ; /* 32 x 32 integer multiply (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Multiply 32-Bit Operands instruction multiplies two 32-bit data reg-
isters (dest_reg and multiplier_register) and saves the product in
dest_reg. The instruction mimics multiplication in the C language and
effectively performs Dreg1 = (Dreg1 * Dreg2) modulo 232. Since the
integer multiply is modulo 232, the result always fits in a 32-bit dest_reg,
and overflows are possible but not detected. The overflow flag in the
ASTAT register is never set.
Users are required to limit input numbers to ensure that the resulting
product does not exceed the 32-bit dest_reg capacity. If overflow notifi-
cation is required, users should write their own multiplication macro with
that capability.
Accumulators A0 and A1 are unchanged by this instruction.
The Multiply 32-Bit Operands instruction does not implicitly modify the
number in multiplier_register.

This instruction might be used to implement the congruence method of

random number generation according to:
32
X [ n + a ] = ( a × X [ n ] )mod 2
where:
• X[n] is the seed value,
• a is a large integer, and
• X[n+1] is the result that can be multiplied again to further the
pseudo-random sequence.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
r3 *= r0 ;
Also See
DIVS, DIVQ (Divide Primitive), Arithmetic Shift, Shift with Add, Add
with Shift, Vector Multiply and Multiply-Accumulate, Vector Multiply
None

Multiply and Multiply-Accumulate to Accumulator
General Form
accumulator = src_reg_0 * src_reg_1 (opt_mode)
accumulator += src_reg_0 * src_reg_1 (opt_mode)
accumulator –= src_reg_0 * src_reg_1 (opt_mode)
Syntax
Multiply-And-Accumulate Unit 0 (MAC0) Operations
A0 =Dreg_lo_hi * Dreg_lo_hi (opt_mode) ; /* multiply and
store (b) */
A0 += Dreg_lo_hi * Dreg_lo_hi (opt_mode) ; /* multiply and
add (b) */
A0 –= Dreg_lo_hi * Dreg_lo_hi (opt_mode) ; /* multiply and
subtract (b) */
Multiply-And-Accumulate Unit 1 (MAC1) Operations

A1 = Dreg_lo_hi * Dreg_lo_hi (opt_mode) ; /* multiply and
store (b) */
A1 += Dreg_lo_hi * Dreg_lo_hi (opt_mode) ; /* multiply and
add (b) */
A1 –= Dreg_lo_hi * Dreg_lo_hi (opt_mode) ; /* multiply and
subtract (b) */
Syntax Terminology
opt_mode: Optionally (FU), (IS), or (W32). Optionally, (M) can be used

on MAC1 versions either alone or with (W32). If multiple options are
specified together for a MAC, the options must be separated by commas
and enclosed within a single set of parenthesis. Example: (M, W32)

Instruction Length
The Multiply and Multiply-Accumulate to Accumulator instruction mul-
tiplies two 16-bit half-word operands. It stores, adds or subtracts the
product into a designated Accumulator with saturation.
The Multiply-and-Accumulate Unit 0 (MAC0) portion of the architecture
performs operations that involve Accumulator A0. MAC1 performs A1
operations.
By default, the instruction treats both operands of both MACs as signed
fractions with left-shift correction as required.
Options
The Multiply and Multiply-Accumulate to Accumulator instruction sup-
ports the following options. Saturation is supported for every option.
When the (M) and (W32) options are used together, both MACs saturate
their Accumulator products at 32 bits. MAC1 multiplies signed fractions
by unsigned fractions and MAC0 multiplies signed fractions.
When used together, the order of the options in the syntax makes no
difference.
In fractional mode, the product of the most negative representable frac-
tion times itself (for example, 0x8000 times 0x8000) is saturated to the
maximum representable positive fraction (0x7FFF) before accumulation.

Table 10-3. Options for Multiply and Multiply-Accumulate to

Accumulator
Option Description
Default Signed fraction. Multiply 1.15 x 1.15 to produce 1.31 format data after shift correc-
tion. Sign extend the result to 9.31 format before passing it to the Accumulator. Sat-
urate the Accumulator after copying or accumulating to maintain 9.31 precision.
Result is between minimum -1 and maximum 1-2-31 (or, expressed in hex, between
minimum 0x80 0000 0000 and maximum 0x7F FFFF FFFF).
(FU) Unsigned fraction. Multiply 0.16 x 0.16 to produce 0.32 format data. Perform no
shift correction. Zero extend the result to 8.32 format before passing it to the Accu-
mulator. Saturate the Accumulator after copying or accumulating to maintain 8.32
precision.
Unsigned integer. Multiply 16.0 x 16.0 to produce 32.0 format data. Perform no
shift correction. Zero extend the result to 40.0 format before passing it to the Accu-
mulator. Saturate the Accumulator after copying or accumulating to maintain 40.0
precision.
In either case, the resulting hexadecimal range is minimum 0x00 0000 0000 through
maximum 0xFF FFFF FFFF.
(IS) Signed integer. Multiply 16.0 x 16.0 to produce 32.0 format data. Perform no shift
correction. Sign extend the result to 40.0 format before passing it to the Accumula-
tor. Saturate the Accumulator after copying or accumulating to maintain 40.0 preci-
sion. Result is between minimum -239 and maximum 239-1 (or, expressed in hex,
between minimum 0x80 0000 0000 and maximum 0x7F FFFF FFFF).
(W32) Signed fraction with 32-bit saturation. Multiply 1.15 x 1.15 to produce 1.31 format
data after shift correction. Sign extend the result to 9.31 format before passing it to
the Accumulator. Saturate the Accumulator after copying or accumulating at bit 31
to maintain 1.31 precision. Result is between minimum -1 and maximum 1-2-31
(or, expressed in hex, between minimum 0xFF 8000 0000 and maximum 0x00 7FFF
FFFF).
No shift correction in either case. Src_reg_0 is the signed operand and Src_reg_1 is
the unsigned operand.
Accumulation and extraction proceed according to the other mode flag or Default.

Flags Affected
• AV0 is set if result in Accumulator A0 (MAC0 operation) saturates;
cleared if A0 result does not saturate.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
a0=r3.h*r2.h ; /* MAC0, only. Both operands are signed frac-
tions. Load the product into A0. */
a1+=r6.h*r4.l (fu) ; /* MAC1, only. Both operands are unsigned
fractions. Accumulate into A1 */

Also See
Multiply 16-Bit Operands, Multiply 32-Bit Operands, Multiply and Mul-
tiply-Accumulate to Half-Register, Multiply and Multiply-Accumulate to
Data Register, Vector Multiply, Vector Multiply and
Multiply-Accumulate
DSP filter applications often use the Multiply and Multiply-Accumulate
to Accumulator instruction to calculate the dot product between two sig-
nal vectors.

Multiply and Multiply-Accumulate to Half-Register
General Form
dest_reg_half = (accumulator = src_reg_0 * src_reg_1) (opt_mode)
dest_reg_half = (accumulator += src_reg_0 * src_reg_1) (opt_mode)
dest_reg_half = (accumulator –= src_reg_0 * src_reg_1) (opt_mode)
Syntax
Dreg_lo = (A0 = Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
tiply and store (b) */
Dreg_lo = (A0 += Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* multi-
ply and add (b) */
Dreg_lo = (A0 –= Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
tiply and subtract (b) */

Dreg_hi = (A1 = Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
Dreg_hi = (A1 += Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
tiply and add (b) */
Dreg_hi = (A1 –= Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
Syntax Terminology
Dreg_lo: R7–0.L
Dreg_hi: R7–0.H

opt_mode: Optionally (FU), (IS), (IU), (T), (TFU), (S2RND), (ISS2) or

(IH). Optionally, (M) can be used with MAC1 versions either alone or
with any of these other options. If multiple options are specified together
for a MAC, the options must be separated by commas and enclosed within
a single set of parentheses. Example: (M, TFU)
Instruction Length
The Multiply and Multiply-Accumulate to Half-Register instruction mul-
tiplies two 16-bit half-word operands. The instruction stores, adds or
subtracts the product into a designated Accumulator. It then copies 16
bits (saturated at 16 bits) of the Accumulator into a data half-register.
The fraction versions of this instruction (the default and “(FU)” options)
transfer the Accumulator result to the destination register according to the
diagrams in Figure 10-1.
The integer versions of this instruction (the “(IS)” and “(IU)” options)
transfer the Accumulator result to the destination register according to the
diagrams in Figure 10-2.
performs operations that involve Accumulator A0 and loads the results
into the lower half of the destination data register. MAC1 performs A1
operations and loads the results into the upper half of the destination data
register.
All versions of this instruction that support rounding are affected by the
RND_MOD bit in the ASTAT register when they copy the results into the desti-
nation register. RND_MOD determines whether biased or unbiased rounding
is used.

A0.X A0.H A0.L
A0.X A0.H A0.L
Figure 10-1. Result to Destination Register (Default and (FU) Options)
A0.X A0.H A0.L
A0.X A0.H A0.L
Figure 10-2. Result to Destination Register ((IS) and (IU) Options)


ing behavior.
Options
The Multiply and Multiply-Accumulate to Half-Register instruction sup-
ports operand and Accumulator copy options.
The options are listed in Table 10-4.
Table 10-4. Operand and Accumulator Copy Options of Multiply and

Multiply-Accumulate to Half-Register
Option Description
Default Signed fraction format. Multiply 1.15 * 1.15 formats to produce 1.31 results after
shift correction. The special case of 0x8000 * 0x8000 is saturated to 0x7FFF FFFF
to fit the 1.31 result.
Sign extend 1.31 result to 9.31 format before copying or accumulating to Accumu-
lator. Then, saturate Accumulator to maintain 9.31 precision; Accumulator result
is between minimum 0x80 0000 0000 and maximum 0x7F FFFF FFFF.
To extract to half-register, round Accumulator 9.31 format value at bit 16.
(RND_MOD bit in the ASTAT register controls the rounding.) Saturate the result
to 1.15 precision and copy it to the destination register half. Result is between
minimum -1 and maximum 1-2-15 (or, expressed in hex, between minimum
(FU) Unsigned fraction format. Multiply 0.16* 0.16 formats to produce 0.32 results.
No shift correction. The special case of 0x8000 * 0x8000 yields 0x4000 0000. No
saturation is necessary since no shift correction occurs.
Zero extend 0.32 result to 8.32 format before copying or accumulating to Accu-
mulator. Then, saturate Accumulator to maintain 8.32 precision; Accumulator
result is between minimum 0x00 0000 0000 and maximum 0xFF FFFF FFFF.
(RND_MOD bit in the ASTAT register controls the rounding.) Saturate the result
to 0.16 precision and copy it to the destination register half. Result is between
minimum 0 and maximum 1-2-16 (or, expressed in hex, between minimum
0x0000 and maximum 0xFFFF).


Multiply-Accumulate to Half-Register (Cont’d)
Option Description
(IS) Signed integer format. Multiply 16.0 * 16.0 formats to produce 32.0 results. No
shift correction.
Extract the lower 16 bits of the Accumulator. Saturate for 16.0 precision and copy
to the destination register half. Result is between minimum -215 and maximum
215-1 (or, expressed in hex, between minimum 0x8000 and maximum 0x7FFF).
(IU) Unsigned integer format. Multiply 16.0 * 16.0 formats to produce 32.0 results.
No shift correction.
Extract the lower 16 bits of the Accumulator. Saturate for 16.0 precision and copy
to the destination register half. Result is between minimum 0 and maximum
216-1 (or, expressed in hex, between minimum 0x0000 and maximum 0xFFFF).
(T) Signed fraction with truncation. Multiply 1.15 * 1.15 formats to produce 1.31
results after shift correction. The special case of 0x8000 * 0x8000 is saturated to
0x7FFF FFFF to fit the 1.31 result. (Same as the Default mode.)
To extract to half-register, truncate Accumulator 9.31 format value at bit 16. (Per-
form no rounding.) Saturate the result to 1.15 precision and copy it to the destina-
tion register half. Result is between minimum -1 and maximum 1-2-15 (or,
expressed in hex, between minimum 0x8000 and maximum 0x7FFF).


Option Description
(TFU) Unsigned fraction with truncation. Multiply 0.16* 0.16 formats to produce 0.32
results. No shift correction. The special case of 0x8000 * 0x8000 yields 0x4000
0000. No saturation is necessary since no shift correction occurs. (Same as the FU
mode.)
To extract to half-register, truncate Accumulator 8.32 format value at bit 16. (Per-
form no rounding.) Saturate the result to 0.16 precision and copy it to the destina-
tion register half. Result is between minimum 0 and maximum 1-2-16 (or,
expressed in hex, between minimum 0x0000 and maximum 0xFFFF).
(S2RND) Signed fraction with scaling and rounding. Multiply 1.15 * 1.15 formats to pro-
duce 1.31 results after shift correction. The special case of 0x8000 * 0x8000 is sat-
urated to 0x7FFF FFFF to fit the 1.31 result. (Same as the Default mode.)
To extract to half-register, shift the Accumulator contents one place to the left
(multiply x 2). Round Accumulator 9.31 format value at bit 16. (RND_MOD bit
in the ASTAT register controls the rounding.) Saturate the result to 1.15 precision
and copy it to the destination register half. Result is between minimum -1 and
maximum 1-2-15 (or, expressed in hex, between minimum 0x8000 and maximum
0x7FFF).
(ISS2) Signed integer with scaling. Multiply 16.0 * 16.0 formats to produce 32.0 results.
No shift correction. (Same as the IS mode.)
Extract the lower 16 bits of the Accumulator. Shift them one place to the left
(multiply x 2). Saturate the result for 16.0 format and copy to the destination reg-
ister half. Result is between minimum -215 and maximum 215-1 (or, expressed in
hex, between minimum 0x8000 and maximum 0x7FFF).


Option Description
(IH) Signed integer, high word extract. Multiply 16.0 * 16.0 formats to produce 32.0
results. No shift correction. (Same as the IS mode.)
(RND_MOD bit in the ASTAT register controls the rounding.) Saturate to 32.0
result. Copy the upper 16 bits of that value to the destination register half. Result
is between minimum -215 and maximum 215-1 (or, expressed in hex, between
minimum 0x8000 and maximum 0x7FFF).
No shift correction in either case. Src_reg_0 is the signed operand and Src_reg_1
is the unsigned operand.
When necessary, saturation is performed after the rounding.
The accumulator is unaffected by extraction.
If you want to keep the unaltered contents of the Accumulator, use a sim-
ple Move instruction to copy An.X or An.W to or from a register.

Flags Affected
• V is set if the result extracted to the Dreg saturates; cleared if no
saturation.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
r3.l=(a0=r3.h*r2.h) ; /* MAC0, only. Both operands are signed
fractions. Load the product into A0, then copy to r3.l. */
r3.h=(a1+=r6.h*r4.l) (fu) ; /* MAC1, only. Both operands are
unsigned fractions. Add the product into A1, then copy to r3.h */
Also See
Multiply 32-Bit Operands, Multiply and Multiply-Accumulate to Accu-
mulator, Multiply and Multiply-Accumulate to Data Register, Vector
Multiply, Vector Multiply and Multiply-Accumulate
to Half-Register instruction to calculate the dot product between two sig-
nal vectors.

Multiply and Multiply-Accumulate to Data Register
General Form
dest_reg = (accumulator = src_reg_0 * src_reg_1) (opt_mode)
dest_reg = (accumulator += src_reg_0 * src_reg_1) (opt_mode)
dest_reg = (accumulator –= src_reg_0 * src_reg_1) (opt_mode)
Syntax
Dreg_even = (A0 = Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
Dreg_even = (A0 += Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /*
multiply and add (b) */
Dreg_even = (A0 –= Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /*
multiply and subtract (b) */

Dreg_odd = (A1 = Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
Dreg_odd = (A1 += Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
tiply and add (b) */
Dreg_odd = (A1 –= Dreg_lo_hi * Dreg_lo_hi) (opt_mode) ; /* mul-
Syntax Terminology
Dreg_even: R0, R2, R4, R6
Dreg_odd: R1, R3, R5, R7

opt_mode: Optionally (FU), (IS), (S2RND), or (ISS2). Optionally, (M) can

be used with MAC1 versions either alone or with any of these other
options. If multiple options are specified together for a MAC, the options
must be separated by commas and enclosed within a single set of parenthe-
sis. Example: (M, IS)
Instruction Length
This instruction multiplies two 16-bit half-word operands. The instruc-
tion stores, adds or subtracts the product into a designated Accumulator.
It then copies 32 bits of the Accumulator into a data register. The 32 bits
are saturated at 32 bits.
performs operations that involve Accumulator A0; it loads the results into
an even-numbered data register. MAC1 performs A1 operations and loads
the results into an odd-numbered data register.
Combinations of these instructions can be combined into a single instruc-
tion. See “Vector Multiply and Multiply-Accumulate” on page 14-43.
Options
The Multiply and Multiply-Accumulate to Data Register instruction sup-
ports operand and Accumulator copy options.
These options are as shown in Table 10-5.
The syntax supports only biased rounding. The RND_MOD bit in the ASTAT
register has no bearing on the rounding behavior of this instruction.
ing behavior.


Multiply-Accumulate to Data Register
Option Description
Default Signed fraction format. Multiply 1.15 * 1.15 formats to produce 1.31 results after
shift correction. The special case of 0x8000 * 0x8000 is saturated to 0x7FFF FFFF
to fit the 1.31 result.
To extract, saturate the result to 1.31 precision and copy it to the destination regis-
ter. Result is between minimum -1 and maximum 1-2-31 (or, expressed in hex,
between minimum 0x8000 0000 and maximum 0x7FFF FFFF).
(FU) Unsigned fraction format. Multiply 0.16* 0.16 formats to produce 0.32 results.
No shift correction. The special case of 0x8000 * 0x8000 yields 0x4000 0000. No
saturation is necessary since no shift correction occurs.
To extract, saturate the result to 0.32 precision and copy it to the destination regis-
ter. Result is between minimum 0 and maximum 1-2-32 (or, expressed in hex,
between minimum 0x0000 0000 and maximum 0xFFFF FFFF).
(IS) Signed integer format. Multiply 16.0 * 16.0 formats to produce 32.0 results. No
shift correction.
To extract, saturate for 32.0 precision and copy to the destination register. Result
is between minimum -231 and maximum 231-1 (or, expressed in hex, between
minimum 0x8000 0000 and maximum 0x7FFF FFFF).
(S2RND) Signed fraction with scaling and rounding. Multiply 1.15 * 1.15 formats to pro-
duce 1.31 results after shift correction. The special case of 0x8000 * 0x8000 is sat-
urated to 0x7FFF FFFF to fit the 1.31 result. (Same as the Default mode.)
To extract, shift the Accumulator contents one place to the left (multiply x 2), sat-
urate the result to 1.31 precision, and copy it to the destination register. Result is
mum 0x8000 0000 and maximum 0x7FFF FFFF).


Multiply-Accumulate to Data Register (Cont’d)
Option Description
(ISS2) Signed integer with scaling. Multiply 16.0 * 16.0 formats to produce 32.0 results.
No shift correction. (Same as the IS mode.)
To extract, shift the Accumulator contents one place to the left (multiply x 2), sat-
urate the result for 32.0 format, and copy to the destination register. Result is
between minimum -231 and maximum 231-1 (or, expressed in hex, between mini-
mum 0x8000 0000 and maximum 0x7FFF FFFF).
No shift correction in either case. Src_reg_0 is the signed operand and Src_reg_1
is the unsigned operand.
The accumulator is unaffected by extraction.

In fractional mode, the product of the most negative representable frac-
tion times itself (for example, 0x8000 times 0x8000) is saturated to the
maximum representable positive fraction (0x7FFF) before accumulation.
If you want to keep the unaltered contents of the Accumulator, use a sim-
ple Move instruction to copy An.X or An.W to or from a register.

Flags Affected
• V is set if the result extracted to the Dreg saturates; cleared if no
saturation.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
r4=(a0=r3.h*r2.h) ; /* MAC0, only. Both operands are signed
fractions. Load the product into A0, then into r4. */
r3=(a1+=r6.h*r4.l) (fu) ; /* MAC1, only. Both operands are
unsigned fractions. Add the product into A1, then into r3. */
Also See
Move Register, Move Register Half, Multiply 32-Bit Operands, Multiply
and Multiply-Accumulate to Accumulator, Multiply and Multiply-Accu-
mulate to Half-Register, Vector Multiply, Vector Multiply and
Multiply-Accumulate
to Data Register instruction or the vector version (“Vector Multiply and
Multiply-Accumulate” on page 14-43) to calculate the dot product
between two signal vectors.

General Form
dest_reg = – src_reg
dest_accumulator = – src_accumulator
Syntax
Dreg = – Dreg ; /* (a) */
Dreg = – Dreg (sat_flag) ; /* (b) */
A0 = – A0 ; /* (b) */
A0 = – A1 ; /* (b) */
A1 = – A0 ; /* (b) */
A1 = – A1 ; /* (b) */
A1 = – A1, A0 = – A0 ; /* negate both Accumulators simulta-
neously in one 32-bit length instruction (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Negate (Two’s Complement) instruction returns the same magnitude
with the opposite arithmetic sign. The Accumulator versions saturate the
result at 40 bits. The instruction calculates by subtracting from zero.

The Dreg version of the Negate (Two’s Complement) instruction is

offered with or without saturation. The only case where the nonsaturating
Negate would overflow is when the input value is 0x8000 0000. The satu-
rating version returns 0x7FFF FFFF; the nonsaturating version returns
0x8000 0000.
values.
• (S) saturate the result
• (NS) no saturation
Flags Affected
This instruction affects the flags as follows.
• V is set if result overflows or saturates and the dest_reg is a Dreg;
cleared if no overflow or saturation.
saturation.
saturation.



ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
r5 =-r0 ;
a0 =-a0 ;
a0 =-a1 ;
a1 =-a0 ;
a1 =-a1 ;
a1 =-a1, a0=-a0 ;
r0 =-r1(s) ;
r5 =-r0 (ns) ;
Also See
Vector Negate (Two’s Complement)

None

RND (Round to Half-Word)
General Form
dest_reg = src_reg (RND)
Syntax
Dreg_lo_hi =Dreg (RND) ; /* round and saturate the source to
16 bits. (b) */
Syntax Terminology
Dreg: R7– 0
Instruction Length
The Round to Half-Word instruction rounds a 32-bit, normalized-frac-
tion number into a 16-bit, normalized-fraction number by extracting and
saturating bits 31–16, then discarding bits 15–0. The instruction supports
only biased rounding, which adds a half LSB (in this case, bit 15) before
truncating bits 15–0. The ALU performs the rounding. The RND_MOD bit
in the ASTAT register has no bearing on the rounding behavior of this
instruction.
Fractional data types such as the operands used in this instruction are
always signed.


ing behavior.
Flags Affected
The following flags are affected by this instruction.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
/* If r6 = 0xFFFC FFFF, then rounding to 16-bits with . . . */
r1.l = r6 (rnd) ; // . . . produces r1.l = 0xFFFD
// If r7 = 0x0001 8000, then rounding . . .
r1.h = r7 (rnd) ; // . . . produces r1.h = 0x0002

Also See
Add, Add/Subtract – Prescale Up, Add/Subtract – Prescale Down
None

Saturate
General Form
dest_reg = src_reg (S)
Syntax
A0 = A0 (S) ; /* (b) */
A1 = A1 (S) ; /* (b) */
A1 = A1 (S), A0 = A0 (S) ; /* signed saturate both Accumula-
tors at the 32-bit boundary (b) */
Syntax Terminology
None
Instruction Length
The Saturate instruction saturates the 40-bit Accumulators at 32 bits. The
resulting saturated value is sign extended into the Accumulator extension
bits.

Flags Affected
• ANis set if result is negative; cleared if non-negative. In the case of
two simultaneous operations, AN represents the logical “OR” of the
two.
overflow.
overflow.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
a0 = a0 (s) ;
a1 = a1 (s) ;
a1 = a1 (s), a0 = a0 (s) ;
Also See
Subtract (saturate options), Add (saturate options)
None

SIGNBITS
General Form
dest_reg = SIGNBITS sample_register
Syntax
Dreg_lo = SIGNBITS Dreg ; /* 32-bit sample (b) */
Dreg_lo = SIGNBITS Dreg_lo_hi ; /* 16-bit sample (b) */
Dreg_lo = SIGNBITS A0 ; /* 40-bit sample (b) */
Dreg_lo = SIGNBITS A1 ; /* 40-bit sample (b) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Instruction Length

The Sign Bit instruction returns the number of sign bits in a number, and
can be used in conjunction with a shift to normalize numbers. This
instruction can operate on 16-bit, 32-bit, or 40-bit input numbers.
• For a 16-bit input, Sign Bit returns the number of leading sign bits
minus one, which is in the range 0 through 15. There are no spe-
cial cases. An input of all zeros returns +15 (all sign bits), and an
input of all ones also returns +15.
• For a 32-bit input, Sign Bit returns the number of leading sign bits
minus one, which is in the range 0 through 31. An input of all
zeros or all ones returns +31 (all sign bits).
• For a 40-bit Accumulator input, Sign Bit returns the number of
leading sign bits minus 9, which is in the range –8 through +31. A
negative number is returned when the result in the Accumulator
has expanded into the extension bits; the corresponding normaliza-
tion will shift the result down to a 32-bit quantity (losing
precision). An input of all zeros or all ones returns +31.
The result of the SIGNBITS instruction can be used directly as the argu-
ment to ASHIFT to normalize the number. Resultant numbers will be in
the following formats (S == signbit, M == magnitude bit).
16-bit: S.MMM MMMM MMMM MMMM

32-bit: S.MMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM
40-bit: SSSS SSSS S.MMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM
In addition, the SIGNBITS instruction result can be subtracted directly to

form the new exponent.
The Sign Bit instruction does not implicitly modify the input value. For
32-bit and 16-bit input, the dest_reg and sample_register can be the
same D-register. Doing this explicitly modifies the sample_register.

Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r2.l = signbits r7 ;
r1.l = signbits r5.l ;
r0.l = signbits r4.h ;
r6.l = signbits a0 ;
r5.l = signbits a1 ;
Also See
EXPADJ
You can use the exponent as shift magnitude for array normalization. You
can accomplish normalization by using the ASHIFT instruction directly,
without using special normalizing instructions, as required on other
architectures.

Subtract
General Form
dest_reg = src_reg_1 - src_reg_2
Syntax
32-Bit Operands, 32-Bit Result
Dreg = Dreg - Dreg ; /* no saturation support but shorter
instruction length (a) */
Dreg = Dreg - Dreg (sat_flag) ; /* saturation optionally sup-
ported, but at the cost of longer instruction length (b) */
16-Bit Operands, 16-Bit Result

Dreg_lo_hi = Dreg_lo_hi – Dreg_lo_hi (sat_flag) ; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Subtract instruction subtracts src_reg_2 from src_reg_1 and places
the result in a destination register.

There are two ways to specify subtraction on 32-bit data. One instruction
that is 16-bit instruction length does not support saturation. The other
instruction, which is 32-bit instruction length, optionally supports satura-
tion. The larger DSP instruction can sometimes save execution time
because it can be issued in parallel with certain other instructions. See
“Parallel Issue”.
The instructions for 16-bit data use half-word data register operands and
store the result in a half-word data register.
All the instructions for 16-bit data are 32-bit instruction length.
values.
• (S) saturate the result
• (NS) no saturation
The Subtract instruction has no subtraction equivalent of the addition
syntax for P-registers.
Flags Affected



ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
other instructions.
Example
r5 = r2 - r1 ; /* 16-bit instruction length subtract, no
saturation */
r5 = r2 - r1(ns) ; /* same result as above, but 32-bit
instruction length */
r5 = r2 - r1(s) ; /* saturate the result */
r4.l = r0.l - r7.l (ns) ;
r4.l = r0.l - r7.h (s) ; /* saturate the result */
r0.l = r2.h - r4.l(ns) ;
r1.l = r3.h - r7.h(ns) ;
r4.h = r0.l - r7.l (ns) ;
r4.h = r0.l - r7.h (ns) ;
r0.h = r2.h - r4.l(s) ; /* saturate the result */
r1.h = r3.h - r7.h(ns) ;

Also See
Modify – Decrement, Vector Add / Subtract
None

Subtract Immediate
General Form
register -= constant
Syntax
Ireg -= 2 ; /* decrement Ireg by 2, half-word address pointer
increment (a) */
Ireg -= 4 ; /* word address pointer decrement (a) */
Syntax Terminology
Ireg: I3–0
Instruction Length
The Subtract Immediate instruction subtracts a constant value from an
Index register without saturation.

Ireg


To subtract immediate values from D-registers or P-registers, use a
negative constant in the Add Immediate instruction.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
cific other instructions. For details, see “Issuing Parallel Instructions” on
page 15-1.
Example
i0 -= 4 ;
i2 -= 2 ;
Also See
Add Immediate, Subtract

None


11 EXTERNAL EVENT
MANAGEMENT
Instruction Summary
• “Idle” on page 11-3
• “Core Synchronize” on page 11-5
• “System Synchronize” on page 11-8
• “EMUEXCPT (Force Emulation)” on page 11-11
• “Disable Interrupts” on page 11-13
• “Enable Interrupts” on page 11-15
• “RAISE (Force Interrupt / Reset)” on page 11-17
• “EXCPT (Force Exception)” on page 11-20
• “Test and Set Byte (Atomic)” on page 11-22
• “No Op” on page 11-25
This chapter discusses the instructions that manage external events. Users
can take advantage of these instructions to enable interrupts, force a spe-
cific interrupt or reset to occur, or put the processor in idle state. The
Core Synchronize instruction resolves all pending operations and flushes
the core store buffer before proceeding to the next instruction. The Sys-
tem Synchronize instruction forces all speculative, transient states in the

core and system to complete before processing continues. Other instruc-

tions in this chapter force an emulation exception, placing the processor in
Emulation mode; test the value of a specific, indirectly-addressed byte; or
increment the Program Counter (PC) without performing useful work.

External Event Management
Idle
General Form
IDLE
Syntax
IDLE ; /* (a) */
Instruction Length
Typically, the Idle instruction is part of a sequence to place the Blackfin
processor in a quiescent state so that the external system can switch
between core clock frequencies.
The IDLE instruction requests an idle state by setting the idle_req bit in
SEQSTAT register. Setting the idle_req bit precedes placing the Blackfin
processor in a quiescent state. If you intend to place the processor in Idle
mode, the IDLE instruction must immediately precede an SSYNC
instruction.
The first instruction following the SSYNC is the first instruction to execute
when the processor recovers from Idle mode.
The Idle instruction is the only way to set the idle_req bit in SEQSTAT.
The architecture does not support explicit writes to SEQSTAT.
Flags Affected
None

Required Mode
The Idle instruction executes only in Supervisor mode. If execution is
attempted in User mode, the instruction produces an Illegal Use of Pro-
tected Resource exception.
Parallel Issue
Example
idle ;
Also See
System Synchronize
None

Core Synchronize
General Form
CSYNC
Syntax
CSYNC ; /* (a) */
Instruction Length
The Core Synchronize (CSYNC) instruction ensures resolution of all pend-
ing core operations and the flushing of the core store buffer before
proceeding to the next instruction. Pending core operations include any
speculative states (for example, branch prediction) or exceptions. The core
store buffer lies between the processor and the L1 cache memory.
CCYNC is typically used after core MMR writes to prevent imprecise
behavior.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
The Core Synchronize instruction cannot be issued in parallel with other
instructions.

Example
Consider the following example code sequence.
if cc jump away_from_here ; /* produces speculative branch
prediction */
csync ;
r0 = [p0] ; /* load */
In this example, the CSYNC instruction ensures that the load instruction is
not executed speculatively. CSYNC ensures that the conditional branch is
resolved and any entries in the processor store buffer have been flushed. In
addition, all speculative states or exceptions complete processing before
CSYNC completes.
Also See
System Synchronize
Use CSYNC to enforce a strict execution sequence on loads and stores or to
conclude all transitional core states before reconfiguring the core modes.
For example, issue CSYNC before configuring memory-mapped registers
(MMRs). CSYNC should also be issued after stores to MMRs to make sure
the data reaches the MMR before the next instruction is fetched.
Typically, the Blackfin processor executes all load instructions strictly in
the order that they are issued and all store instructions in the order that
they are issued. However, for performance reasons, the architecture relaxes
ordering between load and store operations. It usually allows load opera-
tions to access memory out of order with respect to store operations.
Further, it usually allows loads to access memory speculatively. The core

may later cancel or restart speculative loads. By using the Core Synchro-
nize or System Synchronize instructions and managing interrupts
appropriately, you can restrict out-of-order and speculative behavior.
L Stores never access memory speculatively.

System Synchronize
General Form
SSYNC
Syntax
SSYNC ; /* (a) */
Instruction Length
The System Synchronize (SSYNC) instruction forces all speculative, tran-
sient states in the core and system to complete before processing
continues. Until SSYNC completes, no further instructions can be issued to
the pipeline.
The SSYNC instruction performs the same function as Core Synchronize
(CSYNC). In addition, SSYNC flushes any write buffers (between the L1
memory and the system interface) and generates a Synch request signal to
the external system. The operation requires an acknowledgement
Synch_Ack signal by the system before completing the instruction.
If the idle_req bit of the SEQSTAT register is set when SSYNC is executed,
the processor enters Idle state and asserts the external Idle signal after
receiving the external Synch_Ack signal. After the external Idle signal is
asserted, exiting the Idle state requires an external Wakeup signal.
SSYNC should be issued immediately before and after writing to a system
MMR. Otherwise, the MMR change can take effect at an indeterminate
time while other instructions are executing, resulting in imprecise
behavior.

Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
The SSYNC instruction cannot be issued in parallel with other instructions.
Example
Consider the following example code sequence.
if cc jump away_from_here ; /* produces speculative branch
prediction */
ssync ;
r0 = [p0] ; /* load */
In this example, SSYNC ensures that the load instruction will not be exe-
cuted speculatively. The instruction ensures that the conditional branch is
resolved and any entries in the processor store buffer and write buffer have
been flushed. In addition, all exceptions complete processing before SSYNC
completes.
Also See
Core Synchronize, Idle
Typically, SSYNC prepares the architecture for clock cessation or frequency
change. In such cases, the following instruction sequence is typical.
:
instruction...

instruction...
CLI r0 ; /* disable interrupts */
idle ; /* enable Idle state */
ssync ; /* conclude all speculative states, assert external
Sync signal, await Synch_Ack, then assert external Idle signal
and stall in the Idle state until the Wakeup signal. Clock input
can be modified during the stall. */
sti r0 ; /* re-enable interrupts when Wakeup occurs */
instruction...
instruction...

EMUEXCPT (Force Emulation)
General Form
EMUEXCPT
Syntax
EMUEXCPT ; /* (a) */
Instruction Length
The Force Emulation instruction forces an emulation exception, thus
allowing the processor to enter emulation mode.
When emulation is enabled, the processor immediately takes an exception
into emulation mode. When emulation is disabled, EMUEXCPT generates an
illegal instruction exception.
An emulation exception is the highest priority event in the processor.
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
The Force Emulation instruction cannot be issued in parallel with other
instructions.

Example
emuexcpt ;
Also See
RAISE (Force Interrupt / Reset)
None

Disable Interrupts
General Form
CLI
Syntax
CLI Dreg ; /* previous state of IMASK moved to Dreg (a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Disable Interrupts instruction globally disables general interrupts by
setting IMASK to all zeros. In addition, the instruction copies the previous
contents of IMASK into a user-specified register in order to save the state of
the interrupt system.
The Disable Interrupts instruction does not mask NMI, reset, exceptions
and emulation.
Flags Affected
None
Required Mode
The Disable Interrupts instruction executes only in Supervisor mode. If
execution is attempted in User mode, the instruction produces an Illegal
Use of Protected Resource exception.

Parallel Issue
The Disable Interrupts instruction cannot be issued in parallel with other
instructions.
Example
cli r3 ;
Also See
Enable Interrupts
This instruction is often issued immediately before an IDLE instruction.

Enable Interrupts
General Form
STI
Syntax
STI Dreg ; /* previous state of IMASK restored from Dreg
(a) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Enable Interrupts instruction globally enables interrupts by restoring
the previous state of the interrupt system back into IMASK.
Flags Affected
None
Required Mode
The Enable Interrupts instruction executes only in Supervisor mode. If
execution is attempted in User mode, the instruction produces an Illegal
Use of Protected Resource exception.

Parallel Issue
The Enable Interrupts instruction cannot be issued in parallel with other
instructions.
Example
sti r3 ;
Also See
Disable Interrupts
This instruction is often located after an IDLE instruction so that it will
execute after a wake-up event from the idle state.

RAISE (Force Interrupt / Reset)
General Form
RAISE
Syntax
RAISE uimm4 ; /* (a) */
Syntax Terminology
uimm4: 4-bit unsigned field, with the range of 0 through 15
Instruction Length
The Force Interrupt / Reset instruction forces a specified interrupt or reset
to occur. Typically, it is a software method of invoking a hardware event
for debug purposes.
When the RAISE instruction is issued, the processor sets a bit in the ILAT
register corresponding to the interrupt vector specified by the uimm4 con-
stant in the instruction. The interrupt executes when its priority is high
enough to be recognized by the processor. The RAISE instruction causes
these events to occur given the uimm4 arguments shown in Table 11-1.
Table 11-1. uimm4 Arguments and Events

uimm4 Event
0 <reserved>
1 RST
2 NMI

Table 11-1. uimm4 Arguments and Events (Cont’d)

uimm4 Event
3 <reserved>
4 <reserved>
5 IVHW
6 IVTMR
7 ICG7
8 IVG8
9 IVG9
10 IVG10
11 IVG11
12 IVG12
13 IVG13
14 IVG14
15 IVG15
The Force Interrupt / Reset instruction cannot invoke Exception (EXC)

or Emulation (EMU) events; use the EXCPT and EMUEXCPT instructions,
respectively, for those events.
The RAISE instruction does not take effect before the write-back stage in
the pipeline.
Flags Affected
None

Required Mode
The Force Interrupt / Reset instruction executes only in Supervisor mode.
If execution is attempted in User mode, the Force Interrupt / Reset
instruction produces an Illegal Use of Protected Resource exception.
Parallel Issue
The Force Interrupt / Reset instruction cannot be issued in parallel with
other instructions.
Example
raise 1 ; /* Invoke RST */
raise 6 ; /* Invoke IVTMR timer interrupt */
Also See
EXCPT (Force Exception), EMUEXCPT (Force Emulation)
None

EXCPT (Force Exception)
General Form
EXCPT
Syntax
EXCPT uimm4 ; /* (a) */
Syntax Terminology
uimm4: 4-bit unsigned field, with the range of 0 through 15
Instruction Length
The Force Exception instruction forces an exception with code uimm4.
When the EXCPT instruction is issued, the sequencer vectors to the excep-
tion handler that the user provides.
Application-level code uses the Force Exception instruction for operating
system calls. The instruction does not set the EVSW bit (bit 3) of the ILAT
register.
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
The Force Exception instruction cannot be issued in parallel with other
instructions.
Example
excpt 4 ;
Also See
None
None

Test and Set Byte (Atomic)
General Form
TESTSET
Syntax
TESTSET ( Preg ) ; /* (a) */
Syntax Terminology
Preg: P5–0 (SP and FP are not allowed as the register for this instruction)
Instruction Length
The Test and Set Byte (Atomic) instruction loads an indirectly addressed
memory byte, tests whether it is zero, then sets the most significant bit of
the memory byte without affecting any other bits. If the byte is originally
zero, the instruction sets the CC bit. If the byte is originally nonzero the
instruction clears the CC bit. The sequence of this memory transaction is
atomic.
TESTSET accesses the entire logical memory space except the core Mem-
ory-Mapped Register (MMR) address region. The system design must
ensure atomicity for all memory regions that TESTSET may access. The
hardware does not perform atomic access to L1 memory space configured
as SRAM. Therefore, semaphores must not reside in on-core memory.
The memory architecture always treats atomic operations as cache-inhib-
ited accesses, even if the CPLB descriptor for the address indicates a
cache-enabled access. If a cache hit is detected, the operation flushes and
invalidates the line before allowing the TESTSET to proceed.

The software designer is responsible for executing atomic operations in the

proper cacheable / non-cacheable memory space. Typically, these opera-
tions should execute in non-cacheable, off-core memory. In a chip
implementation that requires tight temporal coupling between processors
or processes, the design should implement a dedicated, non-cacheable
block of memory that meets the data latency requirements of the system.
TESTSET can be interrupted before the load portion of the instruction
completes. If interrupted, the TESTSET will be re-executed upon return
from the interrupt. After the test or load portion of the TESTSET com-
pletes, the TESTSET sequence cannot be interrupted. For example, any
exceptions associated with the CPLB lookup for both the load and store
operations must be completed before the load of the TESTSET completes.
The integrity of the TESTSET atomicity depends on the L2 memory
resource-locking mechanism. If the L2 memory does not support atomic
locking for the address region you are accessing, your software has no
guarantee of correct semaphore behavior. See the processor L2 memory
documentation for more on the locking support.
Flags Affected
• CC is set if addressed value is zero; cleared if nonzero.

ASTAT
on page A-2.
Required Mode
User & Supervisor

Parallel Issue
The TESTSET instruction cannot be issued in parallel with other
instructions.
Example
testset (p1) ;
The TESTSET instruction may be preceded by a CSYNC or SSYNC instruction

to ensure that all previous exceptions or interrupts have been processed
before the atomic operation begins.
Also See
Core Synchronize, System Synchronize
Typically, use TESTSET as a semaphore sampling method between copro-
cessors or coprocesses.

No Op
General Form
NOP
MNOP
Syntax
NOP ; /* (a) */
MNOP ; /* (b) */
Instruction Length
The No Op instruction increments the PC and does nothing else.
Typically, the No Op instruction allows previous instructions time to
complete before continuing with subsequent instructions. Other uses are
to produce specific delays in timing loops or to act as hardware event tim-
ers and rate generators when no timers and rate generators are available.
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
cific other instructions. For details, see “Issuing Parallel Instructions” on
page 15-1.
Example
nop ;
mnop ;
mnop || /* a 16-bit instr. */ || /* a 16-bit instr. */ ;
Also See
None
MNOP can be used to issue loads or store instructions in parallel without
invoking a 32-bit MAC or ALU operation. Refer to “Issuing Parallel
Instructions” on page 15-1 for more information.

12 CACHE CONTROL
Instruction Summary
• “PREFETCH” on page 12-2
• “FLUSH” on page 12-4
• “FLUSHINV” on page 12-6
• “IFLUSH” on page 12-8
This chapter discusses the instructions that control cache. Users can take
advantage of these instructions to prefetch or flush the data cache, invali-
date data cache lines, or flush the instruction cache.

PREFETCH
General Form
PREFETCH
Syntax
PREFETCH [ Preg ] ; /* indexed (a) */
PREFETCH [ Preg ++ ] ; /* indexed, post increment (a) */
Syntax Terminology
Instruction Length
The Data Cache Prefetch instruction causes the data cache to prefetch the
cache line that is associated with the effective address in the P-register.
The operation causes the line to be fetched if it is not currently in the data
cache and if the address is cacheable (that is, if bit CPLB_L1_CHBL = 1). If
the line is already in the cache or if the cache is already fetching a line, the
prefetch instruction performs no action, like a NOP.
This instruction does not cause address exception violations. If a protec-
tion violation associated with the address occurs, the instruction acts as a
NOP and does not cause a protection violation exception.
Options
The instruction can post-increment the line pointer by the cache line size.

Cache Control
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
prefetch [ p2 ] ;
prefetch [ p0 ++ ] ;
Also See
None
None

FLUSH
General Form
FLUSH
Syntax
FLUSH [ Preg ] ; /* indexed (a) */
FLUSH [ Preg ++ ] ; /* indexed, post increment (a) */
Syntax Terminology
Instruction Length
The Data Cache Flush instruction causes the data cache to synchronize
the specified cache line with higher levels of memory. This instruction
selects the cache line corresponding to the effective address contained in
the P-register. If the cached data line is dirty, the instruction writes the
line out and marks the line clean in the data cache. If the specified data
cache line is already clean or the cache does not contain the address in the
P-register, this instruction performs no action, like a NOP.
Options

Cache Control
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
The instruction cannot be issued in parallel with other instructions.
Example
flush [ p2 ] ;
flush [ p0 ++ ] ;
Also See
None
None

FLUSHINV
General Form
FLUSHINV
Syntax
FLUSHINV [ Preg ] ; /* indexed (a) */
FLUSHINV [ Preg ++ ] ; /* indexed, post increment (a) */
Syntax Terminology
Instruction Length
The Data Cache Line Invalidate instruction causes the data cache to inval-
idate a specific line in the cache. The contents of the P-register specify the
line to invalidate. If the line is in the cache and dirty, the cache line is
written out to the next level of memory in the hierarchy. If the line is not
in the cache, the instruction performs no action, like a NOP.
Options

Cache Control
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
The Data Cache Line Invalidate instruction cannot be issued in parallel
with other instructions.
Example
flushinv [ p2 ] ;
flushinv [ p0 ++ ] ;
Also See
None
None

IFLUSH
General Form
IFLUSH
Syntax
IFLUSH [ Preg ] ; /* indexed (a) */
IFLUSH [ Preg ++ ] ; /* indexed, post increment (a) */
Syntax Terminology
Instruction Length
The Instruction Cache Flush instruction causes the instruction cache to
invalidate a specific line in the cache. The contents of the P-register spec-
ify the line to invalidate. The instruction cache contains no dirty bit.
Consequently, the contents of the instruction cache are never flushed to
higher levels.
Options

Cache Control
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue
Example
iflush [ p2 ] ;
iflush [ p0 ++ ] ;
Also See
None
None


13 VIDEO PIXEL OPERATIONS
Instruction Summary
• “ALIGN8, ALIGN16, ALIGN24” on page 13-3
• “DISALGNEXCPT” on page 13-6
• “BYTEOP3P (Dual 16-Bit Add / Clip)” on page 13-8
• “Dual 16-Bit Accumulator Extraction with Addition” on
page 13-13
• “BYTEOP16P (Quad 8-Bit Add)” on page 13-15
• “BYTEOP1P (Quad 8-Bit Average – Byte)” on page 13-19
• “BYTEOP2P (Quad 8-Bit Average – Half-Word)” on page 13-24
• “BYTEPACK (Quad 8-Bit Pack)” on page 13-30
• “BYTEOP16M (Quad 8-Bit Subtract)” on page 13-33
• “SAA (Quad 8-Bit Subtract-Absolute-Accumulate)” on page 13-37
• “BYTEUNPACK (Quad 8-Bit Unpack)” on page 13-42

This chapter discusses the instructions that manipulate video pixels. Users
can take advantage of these instructions to align bytes, disable exceptions
that result from misaligned 32-bit memory accesses, and perform dual and
quad 8- and 16-bit add, subtract, and averaging operations.

Video Pixel Operations
ALIGN8, ALIGN16, ALIGN24
General Form
dest_reg = ALIGN8 ( src_reg_1, src_reg_0 )
dest_reg = ALIGN16 (src_reg_1, src_reg_0 )
dest_reg = ALIGN24 (src_reg_1, src_reg_0 )
Syntax
Dreg = ALIGN8 ( Dreg, Dreg ) ; /* overlay 1 byte (b) */
Dreg = ALIGN16 ( Dreg, Dreg ) ; /* overlay 2 bytes (b) */
Dreg = ALIGN24 ( Dreg, Dreg ) ; /* overlay 3 bytes (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Byte Align instruction copies a contiguous four-byte unaligned word
from a combination of two data registers. The instruction version deter-
mines the bytes that are copied; in other words, the byte alignment of the
copied word. Alignment options are shown in Table 13-1.
The ALIGN16 version performs the same operation as the Vector Pack
instruction using the dest_reg = PACK ( Dreg_lo, Dreg_hi ) syntax.
Use the Byte Align instruction to align data bytes for subsequent sin-
gle-instruction, multiple-data (SIMD) instructions.

Table 13-1. Byte Alignment Options

src_reg_1 src_reg_0
byte7 byte6 byte5 byte4 byte3 byte2 byte1 byte0
dest_reg for ALIGN8: byte4 byte3 byte2 byte1
The input values are not implicitly modified by this instruction. The des-
tination register can be the same D-register as one of the source registers.
Doing this explicitly modifies that source register.
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
// If r3 = 0xABCD 1234 and r4 = 0xBEEF DEAD, then . . .
r0 = align8 (r3, r4) ; /* produces r0 = 0x34BE EFDE, */

r0 = align16 (r3, r4) ; /* produces r0 = 0x1234 BEEF, and */

r0 = align24 (r3, r4) ; /* produces r0 = 0xCD12 34BE, */
Also See
Vector PACK
None

DISALGNEXCPT
General Form
DISALGNEXCPT
Syntax
DISALGNEXCPT ; /* (b) */
Syntax Terminology
None
Instruction Length
The Disable Alignment Exception for Load (DISALGNEXCPT) instruction
prevents exceptions that would otherwise be caused by misaligned 32-bit
memory loads issued in parallel. This instruction only affects misaligned
32-bit load instructions that use I-register indirect addressing.
In order to force address alignment to a 32-bit boundary, the two LSBs of
the address are cleared before being sent to the memory system. The I-reg-
ister is not modified by the DISALIGNEXCPT instruction. Also, any
modifications performed to the I-register by a parallel instruction are not
affected by the DISALIGNEXCPT instruction.
Flags Affected
None

Required Mode
User & Supervisor
Parallel Issue
Example
disalgnexcpt || r1 = [i0++] || r3 = [i1++] ; /* three instruc-
tions in parallel */
disalgnexcpt || [p0 ++ p1] = r5 || r3 = [i1++] ; /* alignment
exception is prevented only for the load */
disalgnexcpt || r0 = [p2++] || r3 = [i1++] ; /* alignment
exception is prevented only for the I-reg load */
Also See
Any Quad 8-Bit instructions, ALIGN8, ALIGN16, ALIGN24
Use the DISALGNEXCPT instruction when priming data registers for Quad
8-Bit single-instruction, multiple-data (SIMD) instructions.
Quad 8-Bit SIMD instructions require as many as sixteen 8-bit operands,
four D-registers worth, to be preloaded with operand data. The operand
data is 8 bits and not necessarily word aligned in memory. Thus, use DIS-
ALGNEXCPT to prevent spurious exceptions for these potentially misaligned
accesses.
During execution, when Quad 8-Bit SIMD instructions perform 8-bit
boundary accesses, they automatically prevent exceptions for misaligned
accesses. No user intervention is required.

BYTEOP3P (Dual 16-Bit Add / Clip)
General Form
dest_reg = BYTEOP3P ( src_reg_0, src_reg_1 ) (LO)
dest_reg = BYTEOP3P ( src_reg_0, src_reg_1 ) (HI)
dest_reg = BYTEOP3P ( src_reg_0, src_reg_1 ) (LO, R)
dest_reg = BYTEOP3P ( src_reg_0, src_reg_1 ) (HI, R)
Syntax
/* forward byte order operands */
Dreg = BYTEOP3P (Dreg_pair, Dreg_pair) (LO) ; /* sum into low
bytes (b) */
Dreg = BYTEOP3P (Dreg_pair, Dreg_pair) (HI) ; /* sum into high
bytes (b) */
/* reverse byte order operands */
Dreg = BYTEOP3P (Dreg_pair, Dreg_pair) (LO, R) ; /* sum into
low bytes (b) */
Dreg = BYTEOP3P (Dreg_pair, Dreg_pair) (HI, R) ; /* sum into
high bytes (b) */
Syntax Terminology
Dreg: R7–0
Dreg_pair: R1:0, R3:2, only
Instruction Length
The Dual 16-Bit Add / Clip instruction adds two 8-bit unsigned values to
two 16-bit signed values, then limits (or “clips”) the result to the 8-bit
unsigned range 0 through 255, inclusive. The instruction loads the results

as bytes on half-word boundaries in one 32-bit destination register. Some

syntax options load the upper byte in the half-word and others load the
lower byte, as shown in Table 13-2, Table 13-4, and Table 13-4.
Table 13-2. Assuming the source registers contain:

31................24 23................16 15..................8 7....................0
aligned_src_reg_0: y1 y0
aligned_src_reg_1: z3 z2 z1 z0
Table 13-3. The versions that load the result into the lower byte–“(LO)”–
produce:
31................24 23................16 15..................8 7....................0
dest_reg: 0.....0 y1 + z3 clipped 0.....0 y0 + z1 clipped

to 8 bits to 8 bits
Table 13-4. And the versions that load the result into the higher byte–
“(HI)”–produce:
31................24 23................16 15..................8 7....................0
dest_reg: y1 + z2 clipped 0 . . . . .0 y0 + z0 clipped 0 . . . . .0

to 8 bits to 8 bits
In either case, the unused bytes in the destination register are filled with
0x00.
The 8-bit and 16-bit addition is performed as a signed operation. The
16-bit operand is sign-extended to 32 bits before adding.
The only valid input source register pairs are R1:0 and R3:2.

The Dual 16-Bit Add / Clip instruction provides byte alignment directly
in the source register pairs src_reg_0 and src_reg_1 based on index regis-
ters I0 and I1.
• The two LSBs of the I0 register determine the byte alignment for
source register pair src_reg_0 (typically R1:0).
The relationship between the I-register bits and the byte alignment is
illustrated in Table 13-5.
In the default source order case (e.g., not the ( – , R) syntax), assuming a
source register pair contains the following.
Table 13-5. I-register Bits and the Byte Alignment

The bytes selected are src_reg_pair_HI src_reg_pair_LO
Two LSB’s of I0 or I1 byte7 byte6 byte5 byte4 byte3 byte2 byte1 byte0
00b: byte3 byte2 byte1 byte0
This instruction prevents exceptions that would otherwise be caused by

misaligned 32-bit memory loads issued in parallel.
Options
The ( – , R) syntax reverses the order of the source registers within each
register pair. Typical high performance applications cannot afford the
overhead of reloading both register pair operands to maintain byte order
for every calculation. Instead, they alternate and load only one register
pair operand each time and alternate between the forward and reverse byte

order versions of this instruction. By default, the low order bytes come
from the low register in the register pair. The ( – , R) option causes the
low order bytes to come from the high register.
In the optional reverse source order case (e.g., using the ( – , R) syntax),
the only difference is the source registers swap places within the register
pair in their byte ordering. Assume a source register pair contains the data
shown in Table 13-6.

The bytes selected are src_reg_pair_LO src_reg_pair_HI
Flags Affected
None
Required Mode
User & Supervisor
Parallel Issue

Example
r3 = byteop3p (r1:0, r3:2) (lo) ;
r3 = byteop3p (r1:0, r3:2) (hi) ;
r3 = byteop3p (r1:0, r3:2) (lo, r) ;
r3 = byteop3p (r1:0, r3:2) (hi, r) ;
Also See
BYTEOP16P (Quad 8-Bit Add)
This instruction is primarily intended for video motion compensation
algorithms. The instruction supports the addition of the residual to a
video pixel value, followed by unsigned byte saturation.

Dual 16-Bit Accumulator Extraction with Addition
General Form
dest_reg_1 = A1.L + A1.H, dest_reg_0 = A0.L + A0.H
Syntax
Dreg = A1.L + A1.H, Dreg = A0.L + A0.H ; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Dual 16-Bit Accumulator Extraction with Addition instruction adds
together the upper half-words (bits 31through 16) and lower half-words
(bits 15 through 0) of each Accumulator and loads each result into a
32-bit destination register.
Each 16-bit half-word in each Accumulator is sign extended before being
added together.
Flags Affected
None
Required Mode
User & Supervisor

Parallel Issue
Example
r4=a1.l+a1.h, r7=a0.l+a0.h ;
Also See
SAA (Quad 8-Bit Subtract-Absolute-Accumulate)
Use the Dual 16-Bit Accumulator Extraction with Addition instruction
for motion estimation algorithms in conjunction with the Quad 8-Bit
Subtract-Absolute-Accumulate instruction.

General Form
(dest_reg_1, dest_reg_0) = BYTEOP16P (src_reg_0, src_reg_1)
(dest_reg_1, dest_reg_0) = BYTEOP16P (src_reg_0, src_reg_1) (R)
Syntax
( Dreg, Dreg ) = BYTEOP16P ( Dreg_pair, Dreg_pair ) ; /* (b) */
( Dreg, Dreg ) = BYTEOP16P ( Dreg_pair, Dreg_pair ) (R)
; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Quad 8-Bit Add instruction adds two unsigned quad byte number
sets byte-wise, adjusting for byte alignment. It then loads the byte-wise
results as 16-bit, zero-extended, half-words in two destination registers, as
shown inTable 13-7 and Table 13-8.

Table 13-7. Source Registers Contain

31................24 23................16 15..................8 7....................0
aligned_src_reg_0: y3 y2 y1 y0
Table 13-8. Destination Registers Receive

31................24 23................16 15..................8 7....................0
aligned_src_reg_0: y1 + z1 y0 + z0
aligned_src_reg_1: y3 + z3 y2 + z2
The Quad 8-Bit Add instruction provides byte alignment directly in the
source register pairs src_reg_0 and src_reg_1 based on index registers I0
and I1.
illustrated below.
In the default source order case (e.g., not the (R) syntax), assume that a
source register pair contains the data shown in Table 13-9.
Options
The (R) syntax reverses the order of the source registers within each regis-
ter pair. Typical high performance applications cannot afford the


from the low register in the register pair. The (R) option causes the low
order bytes to come from the high register.
In the optional reverse source order case (e.g., using the (R) syntax), the
only difference is the source registers swap places within the register pair
in their byte ordering. Assume a source register pair contains the data

The mnemonic derives its name from the fact that the operands are bytes,
the result is 16 bits, and the arithmetic operation is “plus” for addition.

Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
(r1,r2)= byteop16p (r3:2,r1:0) ;
(r1,r2)= byteop16p (r3:2,r1:0) (r) ;
Also See
BYTEOP16M (Quad 8-Bit Subtract)
This instruction provides packed data arithmetic typical of video and
image processing applications.

BYTEOP1P (Quad 8-Bit Average – Byte)
General Form
dest_reg = BYTEOP1P ( src_reg_0, src_reg_1 )
dest_reg = BYTEOP1P ( src_reg_0, src_reg_1 ) (T)
dest_reg = BYTEOP1P ( src_reg_0, src_reg_1 ) (R)
dest_reg = BYTEOP1P ( src_reg_0, src_reg_1 ) (T, R)
Syntax
Dreg = BYTEOP1P (Dreg_pair, Dreg_pair) ; /* (b) */
Dreg = BYTEOP1P (Dreg_pair, Dreg_pair) (T) ; /* truncated (b)
*/
Dreg = BYTEOP1P (Dreg_pair, Dreg_pair) (R) ; /* (b) */
Dreg = BYTEOP1P (Dreg_pair, Dreg_pair) (T, R) ; /* truncated (b)
*/
Syntax Terminology
Dreg: R7–0
Instruction Length
The Quad 8-Bit Average – Byte instruction computes the arithmetic aver-
age of two unsigned quad byte number sets byte wise, adjusting for byte
alignment. This instruction loads the byte-wise results as concatenated
bytes in one 32-bit destination register, as shown in Table 13-11 and
Table 13-12.


31................24 23................16 15..................8 7....................0

31................24 23................16 15..................8 7....................0
dest_reg: avg(y3, z3) avg(y2, z2) avg(y1, z1) avg(y0, z0)
Arithmetic average (or mean) is calculated by summing the two operands,

then shifting right one place to divide by two.
The user has two options to bias the result–truncation or rounding up. By
default, the architecture rounds up the mean when the sum is odd. How-
ever, the syntax supports optional truncation.
See “Rounding and Truncating” on page 1-13 for a description of biased
rounding and truncating behavior.
The RND_MOD bit in the ASTAT register has no bearing on the rounding
behavior of this instruction.
The Quad 8-Bit Average – Byte instruction provides byte alignment
directly in the source register pairs src_reg_0 and src_reg_1 based on
index registers I0 and I1.

illustrated below.
In the default source order case (e.g., not the (R) syntax), assume a source
register pair contains the data shown in Table 13-13.


Options
The Quad 8-Bit Average – Byte instruction supports the following
options.
Table 13-14. Options for Quad 8-Bit Average – Byte

Option Description
Default Rounds up the arithmetic mean.
(T) Truncates the arithmetic mean.

Table 13-14. Options for Quad 8-Bit Average – Byte

Option Description
(R) Reverses the order of the source registers within each register pair. Typical
high performance applications cannot afford the overhead of reloading
both register pair operands to maintain byte order for every calculation.
Instead, they alternate and load only one register pair operand each time
and alternate between the forward and reverse byte order versions of this
instruction. By default, the low order bytes come from the low register in
the register pair. The (R) option causes the low order bytes to come from
the high register.
(T, R) Combines both of the above options.


the result is one word, and the basic arithmetic operation is “plus” for
addition. The single destination register indicates that averaging is
performed.

Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r3 = byteop1p (r1:0, r3:2) ;
r3 = byteop1p (r1:0, r3:2) (r) ;
r3 = byteop1p (r1:0, r3:2) (t) ;
r3 = byteop1p (r1:0, r3:2) (t,r) ;
Also See
This instruction supports binary interpolation used in fractional motion
search and motion compensation algorithms.

BYTEOP2P (Quad 8-Bit Average – Half-Word)
General Form
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (RNDL)
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (RNDH)
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (TL)
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (TH)
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (RNDL, R)
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (RNDH, R)
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (TL, R)
dest_reg = BYTEOP2P ( src_reg_0, src_reg_1 ) (TH, R)
Syntax
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (RNDL) ;
/* round into low bytes (b) */
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (RNDH) ;
/* round into high bytes (b) */
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (TL) ;
/* truncate into low bytes (b) */
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (TH) ;
/* truncate into high bytes (b) */
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (RNDL, R) ;
/* round into low bytes (b) */
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (RNDH, R) ;
/* round into high bytes (b) */
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (TL, R) ;
/* truncate into low bytes (b) */
Dreg = BYTEOP2P (Dreg_pair, Dreg_pair) (TH, R) ;
/* truncate into high bytes (b) */

Syntax Terminology
Dreg: R7–0
Instruction Length
The Quad 8-Bit Average – Half-Word instruction finds the arithmetic
average of two unsigned quad byte number sets byte wise, adjusting for
byte alignment. This instruction averages four bytes together. The instruc-
tion loads the results as bytes on half-word boundaries in one 32-bit
destination register. Some syntax options load the upper byte in the
half-word and others load the lower byte, as shown in Table 13-16,
Table 13-17, and Table 13-18.

31................24 23................16 15..................8 7....................0
Table 13-17. The versions that load the result into the lower byte –
RNDL and TL – produce:
31................24 23................16 15..................8 7....................0
dest_reg: 0......0 avg(y3, y2, z3, 0......0 avg(y1, y0, z1,

z2) z0)
In either case, the unused bytes in the destination register are filled with
0x00.

Table 13-18. And the versions that load the result into the higher byte –
RNDH and TH – produce:
31................24 23................16 15..................8 7....................0
dest_reg: avg(y3, y2, z3, 0......0 avg(y1, y0, z1, 0......0

z2) z0)
Arithmetic average (or mean) is calculated by summing the four byte oper-
ands, then shifting right two places to divide by four.
When the intermediate sum is not evenly divisible by 4, precision may be
lost.
The user has two options to bias the result–truncation or biased rounding.
See “Rounding and Truncating” on page 1-13 for a description of unbi-
ased rounding and truncating behavior.
The RND_MOD bit in the ASTAT register has no bearing on the rounding
behavior of this instruction.
The Quad 8-Bit Average – Half-Word instruction provides byte align-
ment directly in the source register pairs src_reg_0 (typically R1:0) and
src_reg_1 (typically R3:2) based only on the I0 register. The byte align-
ment in both source registers must be identical since only one register
specifies the byte alignment for them both.
illustrated in Table 13-19.
In the default source order case (for example, not the (R) syntax), assume a

Table 13-19. I-register Bits and the ByteAlignment

Options
The Quad 8-Bit Average – Half-Word instruction supports the following
options.
Table 13-20. Options for Quad 8-Bit Average – Half-Word

Option Description
(RND—) Rounds up the arithmetic mean.
(T—) Truncates the arithmetic mean.
(—L) Loads the results into the lower byte of each destination half-word.
(—H) Loads the results into the higher byte of each destination half-word.
( ,R) Reverses the order of the source registers within each register pair. Typical
high performance applications cannot afford the overhead of reloading both
register pair operands to maintain byte order for every calculation. Instead,
they alternate and load only one register pair operand each time and alternate
between the forward and reverse byte order versions of this instruction. By
default, the low order bytes come from the low register in the register pair.
The (R) option causes the low order bytes to come from the high register.
When used together, the order of the options in the syntax makes no
difference.


the result is two half-words, and the basic arithmetic operation is “plus”
for addition. The single destination register indicates that averaging is
performed.
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor

Parallel Issue
Example
r3 = byteop2p (r1:0, r3:2) (rndl) ;
r3 = byteop2p (r1:0, r3:2) (rndh) ;
r3 = byteop2p (r1:0, r3:2) (tl) ;
r3 = byteop2p (r1:0, r3:2) (th) ;
r3 = byteop2p (r1:0, r3:2) (rndl, r) ;
r3 = byteop2p (r1:0, r3:2) (rndh, r) ;
r3 = byteop2p (r1:0, r3:2) (tl, r) ;
r3 = byteop2p (r1:0, r3:2) (th, r) ;
Also See
This instruction supports binary interpolation used in fractional motion
search and motion compensation algorithms.

BYTEPACK (Quad 8-Bit Pack)
General Form
dest_reg = BYTEPACK ( src_reg_0, src_reg_1 )
Syntax
Dreg = BYTEPACK ( Dreg, Dreg ) ; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Quad 8-Bit Pack instruction packs four 8-bit values, half-word
aligned, contained in two source registers into one register, byte aligned as
shown in Table 13-22 and Table 13-23.

31................24 23................16 15..................8 7....................0
src_reg_0: byte1 byte0
src_reg_1: byte3 byte2
Table 13-23. Destination Register Receives

dest_reg: byte3 byte2 byte1 byte0


Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r2 = bytepack (r4,r5) ;
• Assuming:
• R4 = 0xFEED FACE
• R5 = 0xBEEF BADD
then this instruction returns:
• R2 = 0xEFDD EDCE
Also See
BYTEUNPACK (Quad 8-Bit Unpack)

None

General Form
(dest_reg_1, dest_reg_0) = BYTEOP16M (src_reg_0, src_reg_1)
(dest_reg_1, dest_reg_0) = BYTEOP16M (src_reg_0, src_reg_1) (R)
Syntax
(Dreg, Dreg) = BYTEOP16M (Dreg_pair, Dreg_pair) ; /* (b */)
(Dreg, Dreg) = BYTEOP16M (Dreg-pair, Dreg-pair) (R) ; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Quad 8-Bit Subtract instruction subtracts two unsigned quad byte
number sets byte wise, adjusting for byte alignment. The instruction loads
the byte-wise results as sign-extended half-words in two destination regis-
ters, as shown in Table 13-24 and Table 13-25.

31................24 23................16 15..................8 7....................0


31................24 23................16 15..................8 7....................0
dest_reg_0: y1 - z1 y0 - z0
dest_reg_1: y3 - z3 y2 - z2
The Quad 8-Bit Subtract instruction provides byte alignment directly in
the source register pairs src_reg_0 and src_reg_1 based on index registers
I0 and I1.
illustrated shown in Table 13-26.
register pair contains the data shown in Table 13-26.



Options
The (R) syntax reverses the order of the source registers within each regis-
ter pair. Typical high performance applications cannot afford the
from the low register in the register pair. The (R) option causes the low
order bytes to come from the high register.
in their byte ordering. Assume that a source register pair contains the data

the result is 16 bits, and the arithmetic operation is “minus” for
subtraction.

Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
(r1,r2)= byteop16m (r3:2,r1:0) ;
(r1,r2)= byteop16m (r3:2,r1:0) (r) ;
Also See
This instruction provides packed data arithmetic typical of video and
image processing applications.

General Form
SAA ( src_reg_0, src_reg_1 )
SAA ( src_reg_0, src_reg_1 ) (R)
Syntax
SAA (Dreg_pair, Dreg_pair) ; /* forward byte order operands
(b) */
SAA (Dreg_pair, Dreg_pair) (R) ; /* reverse byte order oper-
ands (b) */
Syntax Terminology
Dreg_pair: R1:0, R3:2 (This instruction only supports register pairs R1:0
and R3:2.)
Instruction Length
The Quad 8-Bit Subtract-Absolute-Accumulate instruction subtracts four
pairs of values, takes the absolute value of each difference, and accumu-
lates each result into a 16-bit Accumulator half. The results are placed in
the upper- and lower-half Accumulators A0.H, A0.L, A1.H, and A1.L.
Saturation is performed if an operation overflows a 16-bit Accumulator
half.
Only register pairs R1:0 and R3:2 are valid sources for this instruction.
This instruction supports the following byte-wise Sum of Absolute Differ-
ence (SAD) calculations.

N–1 N–1
SAD = ∑ ∑ a (i,j) – b (i,j)
i=0 j=0
Figure 13-1. Absolute Difference (SAD) Calculations
Typical values for N are 8 and 16, corresponding to the video block size of
8x8 and 16x16 pixels, respectively. The 16-bit Accumulator registers limit
the pixel region or block size to 32x32 pixels.
The SAA instruction behavior is shown below.
Table 13-28. SAA Instruction Behavior

src_reg_0 a(i, j+3) a(i, j+2) a(i, j+1) a(i, j)
src_reg_1 b(i, j+3) b(i, j+2) b(i, j+1) b(i, j)
A1.H +=| a(i, j+3) A1.L +=| a(i, j+2) A0.H +=| a(i, j+1) A0.L +=| a(i, j)
-b(i, j+3) | - b(i, j+2) | - b(i, j+1) | - b(i, j) |
The Quad 8-Bit Subtract-Absolute-Accumulate instruction provides byte

alignment directly in the source register pairs src_reg_0 and src_reg_1
based on index registers I0 and I1.
illustrated below.

register pair contain the data shown in Table 13-29.


Options
The (R) syntax reverses the order of the source registers within each pair.
Typical high performance applications cannot afford the overhead of
reloading both register pair operands to maintain byte order for every cal-
culation. Instead, they alternate and load only one register pair operand
each time and alternate between the forward and reverse byte order ver-
sions of this instruction. By default, the low order bytes come from the
low register in the register pair. The (R) option causes the low order bytes
to come from the high register.
When reversing source order by using the (R) syntax, the source registers
swap places within the register pair in their byte ordering. If a source reg-
ister pair contains the data shown in Table 13-30, then the
SAA instruction computes 12 pixel operations simultaneously–the
three-operation subtract-absolute-accumulate on four pairs of operand
bytes in parallel.


Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
saa (r1:0, r3:2) || r0 = [i0++] || r2 = [i1++] ; /* parallel fill
instructions */
saa (r1:0, r3:2) (R) || r1 = [i0++] || r3 = [i1++] ; /* reverse,
parallel fill instructions */
saa (r1:0, r3:2) ; /* last SAA in a loop, no more fill
required */
Also See
DISALGNEXCPT, Load Data Register
Use the Quad 8-Bit Subtract-Absolute-Accumulate instruction for
block-based video motion estimation algorithms using block Sum of
Absolute Difference (SAD) calculations to measure distortion.

General Form
( dest_reg_1, dest_reg_0 ) = BYTEUNPACK src_reg_pair
( dest_reg_1, dest_reg_0 ) = BYTEUNPACK src_reg_pair (R)
Syntax
( Dreg , Dreg ) = BYTEUNPACK Dreg_pair ; /* (b) */
( Dreg , Dreg ) = BYTEUNPACK Dreg_pair (R) ; /* reverse source
order (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Quad 8-Bit Unpack instruction copies four contiguous bytes from a
pair of source registers, adjusting for byte alignment. The instruction
loads the selected bytes into two arbitrary data registers on half-word
alignment.
The two LSBs of the I0 register determine the source byte alignment, as
illustrated below.
In the default source order case (e.g., not the (R) syntax), assume the


Options
The (R) syntax reverses the order of the source registers within the pair.
Typical high performance applications cannot afford the overhead of
reloading both register pair operands to maintain byte order for every cal-
culation. Instead, they alternate and load only one register pair operand
each time and alternate between the forward and reverse byte order ver-
sions of this instruction. By default, the low order bytes come from the
low register in the register pair. The (R) option causes the low order bytes
to come from the high register.
only difference is the source registers swap places in their byte ordering.
Assume the source register pair contains the data shown in Table 13-32.


The four bytes, now byte aligned, are copied into the destination registers
on half-word alignment, as shown in Table 13-33 and Table 13-34.
Table 13-33. Source Register Contains

31................24 23................16 15..................8 7....................0
Aligned bytes: byte_D byte_C byte_B byte_A

31................24 23................16 15..................8 7....................0
dest_reg_0: byte_B byte_A
dest_reg_1: byte_D byte_C
Only register pairs R1:0 and R3:2 are valid sources for this instruction.
Misaligned access exceptions are disabled during this instruction.
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
(r6,r5) = byteunpack r1:0 ; /* non-reversing sources */
• Assuming:
• register I0’s two LSBs = 00b,
• R6 = 0x00BE 00EF
• R5 = 0x00BA 00DD
• Assuming:
• R6 = 0x00CE 00BE
• R5 = 0x00EF 00BA
• Assuming:


• R6 = 0x00FA 00CE
• R5 = 0x00BE 00EF
• Assuming:
• R6 = 0x00ED 00FA
• R5 = 0x00CE 00BE
(r6,r5) = byteunpack r1:0 (R) ; /* reversing sources case */
• Assuming:
• R6 = 0x00FE 00ED
• R5 = 0x00FA 00CE

• Assuming:
• R6 = 0x00DD 00FE
• R5 = 0x00ED 00FA
• Assuming:
• R6 = 0x00BA 00DD
• R5 = 0x00FE 00ED
• Assuming:
• R6 = 0x00EF 00BA
• R5 = 0x00DD 00FE

Also See
None

14 VECTOR OPERATIONS
Instruction Summary
• “Add on Sign” on page 14-3
• “VIT_MAX (Compare-Select)” on page 14-9
• “Vector ABS” on page 14-16
• “Vector Add / Subtract” on page 14-19
• “Vector Arithmetic Shift” on page 14-25
• “Vector Logical Shift” on page 14-30
• “Vector MAX” on page 14-34
• “Vector MIN” on page 14-37
• “Vector Multiply” on page 14-40
• “Vector Multiply and Multiply-Accumulate” on page 14-43
• “Vector Negate (Two’s Complement)” on page 14-48
• “Vector PACK” on page 14-50
• “Vector SEARCH” on page 14-52

This chapter discusses the instructions that control vector operations.
Users can take advantage of these instructions to perform simultaneous
operations on multiple 16-bit values, including add, subtract, multiply,
shift, negate, pack, and search. Compare-Select and Add-On-Sign are also
included in this chapter.

Vector Operations
Add on Sign
General Form
dest_hi = dest_lo = SIGN (src0_hi) * src1_hi
+ SIGN (src0_lo) * src1_lo
Syntax
Dreg_hi = Dreg_lo = SIGN ( Dreg_hi ) * Dreg_hi
+ SIGN ( Dreg_lo ) * Dreg_lo ;
/* (b) */
Register Consistency
The destination registers dest_hi and dest_lo must be halves of the same
data register. Similarly, src0_hi and src0_lo must be halves of the same
register and src1_hi and src1_lo must be halves of the same register.
Syntax Terminology
Dreg_hi: R7–0.H
Dreg_lo: R7–0.L
Instruction Length

The Add on Sign instruction performs a two step function, as follows.
1. Multiply the arithmetic sign of a 16-bit half-word number in src0
by the corresponding half-word number in src1. The arithmetic
sign of src0 is either (+1) or (–1), depending on the sign bit of
src0. The instruction performs this operation on the upper and
lower half-words of the same data registers.
The results of this step obey the signed multiplication rules sum-
marized in Table 14-1. Y is the number in src0, and Z is the
number in src1. The numbers in src0 and src1 may be positive or
negative.
Table 14-1.
SRC0 SRC1 Sign-Adjusted SRC1
+Y +Z +Z
+Y –Z –Z
–Y +Z –Z
–Y –Z +Z
Note the result always bears the magnitude of Z with only the sign
affected.
2. Then, add the sign-adjusted src1 upper and lower half-word
results together and store the same 16-bit sum in the upper and
lower halves of the destination register, as shown in Table 14-2 and
Table 14-3.
The sum is not saturated if the addition exceeds 16 bits.

Vector Operations

31................24 23................16 15..................8 7....................0
src0: a1 a0
src1: b1 b0
Table 14-3. Destination Register Receives

31................24 23................16 15..................8 7....................0
dest: (sign_adjusted_b1) + (sign_adjusted_b1) +

(sign_adjusted_b0) (sign_adjusted_b0)
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
r7.h=r7.l=sign(r2.h)*r3.h+sign(r2.l)*r3.l ;
• If
• R2.H =2
• R3.H = 23
• R2.L = 2001
• R3.L = 1234
then
• R7.H = 1257 (or 1234 + 23)
• R7.L = 1257
• If
• R2.H = –2
• R3.H = 23
• R2.L = 2001
• R3.L = 1234

Vector Operations
then
• R7.H = 1211 (or 1234 – 23)
• R7.L = 1211
• If
• R2.H =2
• R3.H = 23
• R2.L = –2001
• R3.L = 1234
then
• R7.H = –1211 (or (–1234) + 23)
• R7.L = –1211
• If
• R2.H = –2
• R3.H = 23
• R2.L = –2001
• R3.L = 1234
then
• R7.H = –1257 (or (–1234) – 23)
• R7.L = –1257
Also See
None

Use the Sum on Sign instruction to compute the branch metric used by
each Viterbi Butterfly.

Vector Operations
VIT_MAX (Compare-Select)
General Form
dest_reg = VIT_MAX ( src_reg_0, src_reg_1 ) (ASL)
dest_reg = VIT_MAX ( src_reg_0, src_reg_1 ) (ASR)
dest_reg_lo = VIT_MAX ( src_reg ) (ASL)
dest_reg_lo = VIT_MAX ( src_reg ) (ASR)
Syntax
Dual 16-Bit Operation
Dreg = VIT_MAX ( Dreg , Dreg ) (ASL) ; /* shift history bits
left (b) */
Dreg = VIT_MAX ( Dreg , Dreg ) (ASR) ; /* shift history bits
right (b) */
Single 16-Bit Operation

Dreg_lo = VIT_MAX ( Dreg ) (ASL) ; /* shift history bits left
(b) */
Dreg_lo = VIT_MAX ( Dreg ) (ASR) ; /* shift history bits right
(b) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
Instruction Length

The Compare-Select (VIT_MAX) instruction selects the maximum values of
pairs of 16-bit operands, returns the largest values to the destination regis-
ter, and serially records in A0.W the source of the maximum.This operation
performs signed operations. The operands are compared as two’s
complements.
Versions are available for dual and single 16-bit operations. Whereas the
dual versions compare four operands to return two maxima, the single ver-
sions compare only two operands to return one maximum.
The Accumulator extension bits (bits 39–32) must be cleared before exe-
cuting this instruction.
This operation is illustrated in Table 14-4 and Table 14-5.

31................24 23................16 15..................8 7....................0
src_reg_0 y1 y0
src_reg_1 z1 z0
Table 14-5. Destination Register Contains

31................24 23................16 15..................8 7....................0
dest_reg Maximum, y1 or y0 Maximum, z1 or z0
Dual 16-Bit Operand Behavior

The ASL version shifts A0 left two bit positions and appends two LSBs to
indicate the source of each maximum as shown in Table 14-6 and
Table 14-7.

Vector Operations
Table 14-6. ASL Version Shifts

A0.X A0.W
A0 00000000 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXBB
Table 14-7. Where

BB Indicates
00 z0 and y0 are maxima
Conversely, the ASR version shifts A0 right two bit positions and appends
two MSBs to indicate the source of each maximum as shown in
Table 14-8 and Table 14-9.
Table 14-8. ASR Version Shifts

A0.X A0.W
A0 00000000 BBXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Table 14-9. Where

BB Indicates
00 y0 and z0 are maxima

Notice that the history bit code depends on the A0 shift direction. The bit
for src_reg_1 is always shifted onto A0 first, followed by the bit for
src_reg_0.
The single operand versions behave similarly.
Single 16-Bit Operand Behavior

If the dual source register contains the data shown in Table 14-10 the des-
tination register receives the data shown in Table 14-11.

31................24 23................16 15..................8 7....................0
src_reg y1 y0

31................24 23................16 15..................8 7....................0
dest_reg_lo Maximum, y1 or y0
The ASL version shifts A0 left one bit position and appends an LSB to
indicate the source of the maximum.
Table 14-12. ASL Version Shifts

A0.X A0.W
A0 00000000 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXB
Conversely, the ASR version shifts A0 right one bit position and appends
an MSB to indicate the source of the maximum.

Vector Operations
Table 14-13. ASR Version Shifts

A0.X A0.W
A0 00000000 BXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Table 14-14. Where

B Indicates
0 y0 is the maximum
1 y1 is the maximum
The path metrics are allowed to overflow, and maximum comparison is

done on the two’s complement circle. Such comparison gives a better indi-
cation of the relative magnitude of two large numbers when a small
number is added/subtracted to both.
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
r5 = vit_max(r3, r2)(asl) ; /* shift left, dual operation */
• Assume:
• R3 = 0xFFFF 0000
• R2 = 0x0000 FFFF
• A0 = 0x00 0000 0000
This example produces:
• R5 = 0x0000 0000
• A0 = 0x00 0000 0002
r7 = vit_max (r1, r0) (asr) ; /* shift right, dual operation */
• Assume:
• R1 = 0xFEED BEEF
• R0 = 0xDEAF 0000
• A0 = 0x00 0000 0000
• R7 = 0xFEED 0000
• A0 = 0x00 8000 0000
r3.l = vit_max (r1)(asl) ; /* shift left, single operation */
• Assume:
• R1 = 0xFFFF 0000
• A0 = 0x00 0000 0000

Vector Operations

• R3.L = 0x0000
• A0 = 0x00 0000 0000
r3.l = vit_max (r1)(asr) ; /* shift right, single operation */
• Assume:
• R1 = 0x1234 FADE
• A0 = 0x00 FFFF FFFF
• R3.L = 0x1234
• A0 = 0x00 7FFF FFFF
Also See
MAX
The Compare-Select (VIT_MAX) instruction is a key element of the
Add-Compare-Select (ACS) function for Viterbi decoders. Combine it
with a Vector Add instruction to calculate a trellis butterfly used in ACS
functions.

Vector ABS
General Form
dest_reg = ABS source_reg (V)
Syntax
Dreg = ABS Dreg (V) ; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Vector Absolute Value instruction calculates the individual absolute
values of the upper and lower halves of a single 32-bit data register. The
results are placed into a 32-bit dest_reg, using the following rules.
• If the input value is positive or zero, copy it unmodified to the
destination.
• If the input value is negative, subtract it from zero and store the
result in the destination.
For example, if the source register contains the data shown in Table 14-15
the destination register receives the data shown in Table 14-16.

31................24 23................16 15..................8 7....................0
src_reg: x.h x.l

Vector Operations

31................24 23................16 15..................8 7....................0
dest_reg: | x.h| | x.l |
This instruction saturates the result.
Flags Affected
• AZ is set if either or both result is zero; cleared if both are nonzero.
• AN is cleared.
• V is set if either or both result saturates; cleared if both are no
saturation.

ASTAT

on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
/* If r1 = 0xFFFF 7FFF, then . . . */
r3 = abs r1 (v) ;
/* . . . produces 0x0001 7FFF */
Also See
ABS
None

Vector Operations
Vector Add / Subtract
General Form
dest = src_reg_0 +|+ src_reg_1
dest = src_reg_0 –|+ src_reg_1
dest = src_reg_0 +|– src_reg_1
dest = src_reg_0 –|– src_reg_1
dest_0 = src_reg_0 +|+ src_reg_1,
dest_1 = src_reg_0 –|– src_reg_1
dest_0 = src_reg_0 +|– src_reg_1,
dest_1 = src_reg_0 –|+ src_reg_1
dest_0 = src_reg_0 + src_reg_1,
dest_1 = src_reg_0 – src_reg_1
dest_0 = A1 + A0, dest_1 = A1 – A0
dest_0 = A0 + A1, dest_1 = A0 – A1
Syntax
Dual 16-Bit Operations
Dreg = Dreg +|+ Dreg (opt_mode_0) ; /* add | add (b) */
Dreg = Dreg –|+ Dreg (opt_mode_0) ; /* subtract | add (b) */
Dreg = Dreg +|– Dreg (opt_mode_0) ; /* add | subtract (b) */
Dreg = Dreg –|– Dreg (opt_mode_0) ; /* subtract | subtract (b) */
Quad 16-Bit Operations

Dreg = Dreg +|+ Dreg, Dreg = Dreg –|– Dreg (opt_mode_0,
opt_mode_2) ;
/* add | add, subtract | subtract; the set of source registers
must be the same for each operation (b) */
Dreg = Dreg +|– Dreg, Dreg = Dreg –|+ Dreg (opt_mode_0,
opt_mode_2) ;
/* add | subtract, subtract | add; the set of source registers
must be the same for each operation (b) */

Dual 32-Bit Operations

Dreg = Dreg + Dreg, Dreg = Dreg – Dreg (opt_mode_1) ;
/* add, subtract; the set of source registers must be the same
for each operation (b) */
Dual 40-Bit Accumulator Operations

Dreg = A1 + A0, Dreg = A1 – A0 (opt_mode_1) ; /* add, sub-
tract Accumulators; subtract A0 from A1 (b) */
Dreg = A0 + A1, Dreg = A0 – A1 (opt_mode_1) ; /* add, sub-
tract Accumulators; subtract A1 from A0 (b) */
Syntax Terminology
Dreg: R7–0
opt_mode_0: optional (S), (CO), or (SCO)

opt_mode_1: optional (S)
opt_mode_2: optional (ASR), or (ASL)
Instruction Length
The Vector Add / Subtract instruction simultaneously adds and/or sub-
tracts two pairs of registered numbers. It then stores the results of each
operation into a separate 32-bit data register or 16-bit half register,
according to the syntax used. The destination register for each of the quad
or dual versions must be unique.

Vector Operations
Options
The Vector Add / Subtract instruction provides three option modes.
• opt_mode_0 supports the Dual and Quad 16-Bit Operations ver-
sions of this instruction.
• opt_mode_1 supports the Dual 32-bit and 40-bit operations.
• opt_mode_2 supports the Quad 16-Bit Operations versions of this
instruction.
Table 14-17 describes the options that the three opt_modes support.
Table 14-17. Options for Opt_Mode 0

Mode Option Description
opt_mode_0 S Saturate the results at 16 bits.
CO Cross option. Swap the order of the results in the destination regis-
ter.
SCO Saturate and cross option. Combination of (S) and (CO) options.
opt_mode_1 S Saturate the results at 16 or 32 bits, depending on the operand size.
opt_mode_2 ASR Arithmetic shift right. Halve the result (divide by 2) before storing
in the destination register. If specified with the S (saturation) flag in
Quad 16-Bit Operand versions of this instruction, the scaling is per-
formed before saturation.
ASL Arithmetic shift left. Double the result (multiply by 2, truncated)
before storing in the destination register. If specified with the S (sat-
uration) flag in Quad 16-Bit Operand versions of this instruction,
the scaling is performed before saturation.
The options shown for opt_mode_2 are scaling options.

Flags Affected
This instruction affects the following flags.
• AZ is set if any results are zero; cleared if all are nonzero.
• AN is set if any results are negative; cleared if all non-negative.
• AC0 is set if the right-hand side of a dual operation generates a
carry; cleared if no carry; unaffected if a quad operation.
• AC1 is set if the left-hand side of a dual operation generates a carry;
cleared if no carry; unaffected if a quad operation.
• V is set if any results overflow; cleared if none overflows.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Vector Operations
Example
r5=r3 +|+ r4 ; /* dual 16-bit operations, add|add */
r6=r0 -|+ r1(s) ; /* same as above, subtract|add with
saturation */
r0=r2 +|- r1(co) ; /* add|subtract with half-word results
crossed over in the destination register */
r7=r3 -|- r6(sco) ; /* subtract|subtract with saturation and
half-word results crossed over in the destination register */
r5=r3 +|+ r4, r7=r3-|-r4 ; /* quad 16-bit operations, add|add,
subtract|subtract */
r5=r3 +|- r4, r7=r3 -|+ r4 ; /* quad 16-bit operations,
add|subtract, subtract|add */
r5=r3 +|- r4, r7=r3 -|+ r4(asr) ; /* quad 16-bit operations,
add|subtract, subtract|add, with all results divided by 2 (right
shifted 1 place) before storing into destination register */
r5=r3 +|- r4, r7=r3 -|+ r4(asl) ; /* quad 16-bit operations,
add|subtract, subtract|add, with all results multiplied by 2
(left shifted 1 place) before storing into destination register
dual */
r2=r0+r1, r3=r0-r1 ; /* 32-bit operations */
r2=r0+r1, r3=r0-r1(s) ; /* dual 32-bit operations with
saturation */
r4=a1+a0, r6=a1-a0 ; /* dual 40-bit Accumulator operations, A0
subtracted from A1 */
r4=a0+a1, r6=a0-a1(s) ; /* dual 40-bit Accumulator operations
with saturation, A1 subtracted from A0 */
Also See
Add, Subtract

FFT butterfly routines in which each of the registers is considered a single
complex number often use the Vector Add / Subtract instruction.
/* If r1 = 0x0003 0004 and r2 = 0x0001 0002, then . . . */
r0 = r2 +|- r1(co) ;
/* . . . produces r0 = 0xFFFE 0004 */

Vector Operations
Vector Arithmetic Shift
General Form
dest_reg = src_reg >>> shift_magnitude (V)
dest_reg = ASHIFT src_reg BY shift_magnitude (V)
Syntax
Dreg = Dreg >>> uimm4 (V) ; /* arithmetic shift right, immedi-
ate (b) */
Dreg = Dreg << uimm4 (V,S) ; /* arithmetic shift left, immedi-
ate with saturation (b) */

Dreg = ASHIFT Dreg BY Dreg_lo (V) ; /* arithmetic shift (b) */
Dreg = ASHIFT Dreg BY Dreg_lo (V, S) ; /* arithmetic shift
with saturation (b) */
Arithmetic Left Shift Immediate

There is no syntax specific to a vector arithmetic left shift immediate
instruction. Use the Vector Logical Shift syntax for vector left shifting,
which accomplishes the same function for sign-extended numbers in num-
ber-normalizing routines. See ““>>>” and “<<” Syntax” notes for caveats.
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
uimm4: unsigned 4-bit field, with a range of 0 through 15

Instruction Length
The Vector Arithmetic Shift instruction arithmetically shifts a pair of
half-word registered numbers a specified distance and direction. Though
the two half-word registers are shifted at the same time, the two numbers
are kept separate.
Arithmetic right shifts preserve the sign of the preshifted value. The sign
bit value backfills the left-most bit position vacated by the arithmetic right
shift. For positive numbers, this behavior is equivalent to the logical right
shift for unsigned numbers.
Only arithmetic right shifts are supported. Left shifts are performed as
logical left shifts that may not preserve the sign of the original number. In
the default case—without the optional saturation option—numbers can
be left shifted so far that all the sign bits overflow and are lost. However,
when the saturation option is enabled, a left shift that would otherwise
shift nonsign bits off the left side saturates to the maximum positive or
negative value instead. So, with saturation enabled, the result always keeps
the same sign as the original number.
“>>>” and “<<” Syntax

The two half-word registers in dest_reg are right shifted by the number of
places specified by shift_magnitude, and the result stored into dest_reg.
The data is always a pair of 16-bit half-registers. Valid shift_magnitude
values are 0 through 15.

Vector Operations
“ASHIFT” Syntax
Both half-word registers in src_reg are shifted by the number of places
prescribed in shift_magnitude, and the result stored into dest_reg.
The sign of the shift magnitude determines the direction of the shift for
the ASHIFT versions.
• Positive shift magnitudes without the saturation flag ( – , S) pro-
duce Logical Left shifts.
• Positive shift magnitudes with the saturation flag ( – , S) produce
Arithmetic Left shifts.
• Negative shift magnitudes produce Arithmetic Right shifts.
In essence, the magnitude is the power of 2 multiplied by the src_reg
number. Positive magnitudes cause multiplication ( N x 2n ), whereas neg-
ative magnitudes produce division ( N x 2-n or N / 2n ).
The dest_reg and src_reg are both pairs of 16-bit half registers. Satura-
tion of the result is optional.
Valid shift magnitudes for 16-bit src_reg are –16 through +15, zero
included. If a number larger than these is supplied, the instruction masks
and ignores the more significant bits.
This instruction does not implicitly modify the src_reg values. Option-
ally, dest_reg can be the same D-register as src_reg. Using the same
D-register for the dest_reg and the src_reg explicitly modifies the source
register.
Options
The ASHIFT instruction supports the ( – , S) option, which saturates the
result.

Flags Affected
• AZ is set if either result is zero; cleared if both are nonzero.
• AN is set if either result is negative; cleared if both are non-negative.
• V is set if either result overflows; cleared if neither overflows.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r4=r5>>>3 (v) ; /* arithmetic right shift immediate R5.H and
R5.L by 3 bits (divide each half-word by 8) If r5 = 0x8004 000F
then the result is r4 = 0xF000 0001 */
r4=r5>>>3 (v, s) ; /* same as above, but saturate the result */
r2=ashift r7 by r5.l (v) ; /* arithmetic shift (right or left,
depending on sign of r5.l) R7.H and R7.L by magnitude of R5.L */

Vector Operations
r2=ashift r7 by r5.l (v, s) ; /* same as above, but saturate

the result */
r2=r5<<7 (v,s) ; /* logical left shift immediate R5.H and R5.L
by 7 bits, saturated */
Also See
Vector Logical Shift, Arithmetic Shift, Logical Shift
None

General Form
dest_reg = src_reg >> shift_magnitude (V)
dest_reg = src_reg << shift_magnitude (V)
dest_reg = LSHIFT src_reg BY shift_magnitude (V)
Syntax
Dreg = Dreg >> uimm4 (V) ; /* logical shift right, immediate
(b) */
Dreg = Dreg << uimm4 (V) ; /* logical shift left, immediate
(b) */

Dreg = LSHIFT Dreg BY Dreg_lo (V) ; /* logical shift (b) */
Syntax Terminology
Dreg: R7–0
Dreg_lo: R7–0.L
uimm4: unsigned 4-bit field, with a range of 0 through 15
Instruction Length
The Vector Logical Shift logically shifts a pair of half-word registered
numbers a specified distance and direction. Though the two half-word
registers are shifted at the same time, the two numbers are kept separate.

Vector Operations
Logical shifts discard any bits shifted out of the register and backfill
vacated bits with zeros.
“>>” AND “<<” Syntax

The two half-word registers in dest_reg are shifted by the number of
places specified by shift_magnitude and the result stored into dest_reg.
The data is always a pair of 16-bit half-registers. Valid shift_magnitude
values are 0 through 15.
“LSHIFT” Syntax
Both half-word registers in src_reg are shifted by the number of places
prescribed in shift_magnitude, and the result is stored into dest_reg.
For the LSHIFT versions, the sign of the shift magnitude determines the
• Positive shift magnitudes produce left shifts.
• Negative shift magnitudes produce right shifts.
The dest_reg and src_reg are both pairs of 16-bit half-registers.
Valid shift magnitudes for 16-bit src_reg are –16 through +15, zero
included. If a number larger than these is supplied, the instruction masks
and ignores the more significant bits.
This instruction does not implicitly modify the src_reg values. Option-
ally, dest_reg can be the same D-register as src_reg. Using the same
D-register for the dest_reg and the src_reg explicitly modifies the source
register at your discretion.

Flags Affected
• AZ is set if either result is zero; cleared if both are nonzero.
• AN is set if either result is negative; cleared if both are non-negative.
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r4=r5>>3 (v) ;
/* logical right shift immediate R5.H and R5.L by 3 bits */
r4=r5<<3 (v) ;
/* logical left shift immediate R5.H and R5.L by 3 bits */
r2=lshift r7 by r5.l (v) ;
/* logically shift (right or left, depending on sign of r5.l)
R7.H and R7.L by magnitude of R5.L */

Vector Operations
Also See
Vector Arithmetic Shift, Arithmetic Shift, Logical Shift
None

Vector MAX
General Form
dest_reg = MAX ( src_reg_0, src_reg_1 ) (V)
Syntax
Dreg = MAX ( Dreg , Dreg ) (V) ; /* dual 16-bit operations
(b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Vector Maximum instruction returns the maximum value (meaning
the largest positive value, nearest to 0x7FFF) of the 16-bit half-word
source registers to the dest_reg.
The instruction compares the upper half-words of src_reg_0 and
src_reg_1 and returns that maximum to the upper half-word of dest_reg.
It also compares the lower half-words of src_reg_0 and src_reg_1 and
returns that maximum to the lower half-word of dest_reg. The result is a
concatenation of the two 16-bit maximum values.
The Vector Maximum instruction does not implicitly modify input val-
ues. The dest_reg can be the same D-register as one of the source
registers. Doing this explicitly modifies that source register.

Vector Operations
Flags Affected
• ANis set if either or both result is negative; cleared if both are
non-negative.
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Example
r7 = max (r1, r0) (v) ;
• Assume R1 = 0x0007 0000 and R0 = 0x0000 000F, then R7 =

0x0007 000F.
• Assume R1 = 0xFFF7 8000 and R0 = 0x000A 7FFF, then R7 =
0x000A 7FFF.
0x1234 5678.
Also See
Vector SEARCH, Vector MIN, MAX, MIN
None

Vector Operations
Vector MIN
General Form
dest_reg = MIN ( src_reg_0, src_reg_1 ) (V)
Syntax
Dreg = MIN ( Dreg , Dreg ) (V) ; /* dual 16-bit operation
(b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Vector Minimum instruction returns the minimum value (the most
negative value or the value closest to 0x8000) of the 16-bit half-word
source registers to the dest_reg.
This instruction compares the upper half-words of src_reg_0 and
src_reg_1 and returns that minimum to the upper half-word of dest_reg.
It also compares the lower half-words of src_reg_0 and src_reg_1 and
returns that minimum to the lower half-word of dest_reg. The result is a
concatenation of the two 16-bit minimum values.
The input values are not implicitly modified by this instruction. The
this explicitly modifies that source register.

Flags Affected
• ANis set if either or both result is negative; cleared if both are
non-negative.
• V is cleared.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue

Vector Operations
Example
r7 = min (r1, r0) (v) ;

0x0000 0000.
• Assume R1 = 0xFFF7 8000 and R0 = 0x000A 7FFF, then R7 =
0xFFF7 8000.
0x0000 000F.
Also See
Vector SEARCH, Vector MAX, MAX, MIN
None

Vector Multiply
Simultaneous Issue and Execution

A pair of compatible, scalar (individual) Multiply 16-Bit Operands
instructions from “Multiply 16-Bit Operands” on page 10-46 can be com-
bined into a single Vector Multiply instruction. The vector instruction
executes the two scalar operations simultaneously and saves the results as a
vector couplet.
See the Arithmetic Operations “Multiply 16-Bit Operands” on
page 10-46 for the scalar instruction details.
Any MAC0 scalar Multiply 16-Bit Operands instruction can be combined
with a compatible MAC1 scalar Multiply 16-Bit Operands instruction
under the following conditions.
• Both scalar instructions must share the same mode option (for
example, default, IS, IU, T). Exception: the MAC1 instruction can
optionally employ the mixed mode (M) that does not apply to
MAC0.
• Both scalar instructions must share the same pair of source regis-
ters, but can reference different halves of those registers.
• Both scalar operations (if they are writes) must write to the same
sized destination registers, either 16 or 32 bits.
• The destination registers for both scalar operations must form a
vector couplet, as described below.
• 16-bit: store results in the upper- and lower-halves of the
same 32-bit Dreg. MAC0 writes to the lower half and
MAC1 writes to the upper half.
• 32-bit: store results in valid Dreg pairs. MAC0 writes to the
pair’s lower (even-numbered) Dreg and MAC1 writes to the
upper (odd-numbered) Dreg.

Vector Operations
Valid Dreg pairs are R7:6, R5:4, R3:2, and R1:0.
Syntax
Separate the two compatible scalar instructions with a comma to produce
a vector instruction. Add a semicolon to the end of the combined instruc-
tion, as usual. The order of the MAC operations on the command line is
arbitrary.
Instruction Length
This instruction is 32 bits long.
Flags Affected
This instruction affects the following flags.
• V is set if any result saturates; cleared if none saturates.

ASTAT
on page A-2.
Example
r2.h=r7.l*r6.h, r2.l=r7.h*r6.h ;
/* simultaneous MAC0 and MAC1 execution, 16-bit results. Both
results are signed fractions. */
r4.l=r1.l*r0.l, r4.h=r1.h*r0.h ;
/* same as above. MAC order is arbitrary. */
r0.h=r3.h*r2.l (m), r0.l=r3.l*r2.l ;

/* MAC1 multiplies a signed fraction by an unsigned fraction.

MAC0 multiplies two signed fractions. */
r5.h=r3.h*r2.h (m), r5.l=r3.l*r2.l (fu) ;
/* MAC1 multiplies signed fraction by unsigned fraction. MAC0
multiplies two unsigned fractions. */
r0.h=r3.h*r2.h, r0.l=r3.l*r2.l (is) ;
/* both MACs perform signed integer multiplication. */
r3.h=r0.h*r1.h, r3.l=r0.l*r1.l (s2rnd) ;
/* MAC1 and MAC0 multiply signed fractions. Both scale the result
on the way to the destination register. */
r0.l=r7.l*r6.l, r0.h=r7.h*r6.h (iss2) ;
/* both MACs process signed integer operands and scale and round
the result on the way to the destination half-registers. */
r7=r2.l*r5.l, r6=r2.h*r5.h ;
/* both operations produce 32-bit results and save in a Dreg
pair. */
r0=r4.l*r7.l, r1=r4.h*r7.h (s2rnd) ;
/* same as above, but with signed fraction scaling mode. Order of
the MAC instructions makes no difference. */

Vector Operations
Vector Multiply and Multiply-Accumulate
Simultaneous Issue and Execution

A pair of compatible, scalar (individual) instructions from
• “Multiply and Multiply-Accumulate to Accumulator” on
page 10-56
• “Multiply and Multiply-Accumulate to Half-Register” on
page 10-61
• “Multiply and Multiply-Accumulate to Data Register” on
page 10-70
can be combined into a single vector instruction. The vector instruction
executes the two scalar operations simultaneously and saves the results as a
vector couplet.
See the Arithmetic Operations sections listed above for the scalar instruc-
tion details.
Any MAC0 scalar instruction from the list above can be combined with a
compatible MAC1 scalar instruction under the following conditions.
• Both scalar instructions must share the same mode option (for
example, default, IS, IU, T). Exception: the MAC1 instruction can
optionally employ the mixed mode (M) that does not apply to
MAC0.
• Both scalar instructions must share the same pair of source regis-
ters, but can reference different halves of those registers.
• If both scalar operations write to destination D-registers, they must
write to the same sized destination D-registers, either 16 or 32 bits.

• The destination D-registers (if applicable) for both scalar opera-

tions must form a vector couplet, as described below.
• 16-bit: store the results in the upper- and lower-halves of
the same 32-bit Dreg. MAC0 writes to the lower half, and
MAC1 writes to the upper half.
• 32-bit: store the results in valid Dreg pairs. MAC0 writes to
the pair’s lower (even-numbered) Dreg, and MAC1 writes to
the upper (odd-numbered) Dreg.
Valid Dreg pairs are R7:6, R5:4, R3:2, and R1:0.
Syntax
Separate the two compatible scalar instructions with a comma to produce
a vector instruction. Add a semicolon to the end of the combined instruc-
tion, as usual. The order of the MAC operations on the command line is
arbitrary.
Instruction Length
This instruction is 32 bits long.
Flags Affected
The flags reflect the results of the two scalar operations.This instruction
affects flags as follows.
• V is set if any result extracted to a Dreg saturates; cleared if no Dregs
saturate.

Vector Operations


ASTAT
on page A-2.
Example
Result is 40-bit Accumulator
a1=r2.l*r3.h, a0=r2.h*r3.h ;
/* both multiply signed fractions into separate Accumulators */
a0=r1.l*r0.l, a1+=r1.h*r0.h ;
/* same as above, but sum result into A1. MAC order is arbitrary.
*/
a1+=r3.h*r3.l, a0-=r3.h*r3.h ;
/* sum product into A1, subtract product from A0 */
a1=r3.h*r2.l (m), a0+=r3.l*r2.l ;
/* MAC1 multiplies a signed fraction in r3.h by an unsigned frac-
tion in r2.l. MAC0 multiplies two signed fractions. */
a1=r7.h*r4.h (m), a0+=r7.l*r4.l (fu) ;
/* MAC1 multiplies signed fraction by unsigned fraction. MAC0
multiplies and accumulates two unsigned fractions. */
a1+=r3.h*r2.h, a0=r3.l*r2.l (is) ;
/* both MACs perform signed integer multiplication */
a1=r6.h*r7.h, a0+=r6.l*r7.l (w32) ;
/* both MACs multiply signed fractions, sign extended, and satu-
rate both Accumulators at bit 31 */

Result is 16-bit half D-register

r2.h=(a1=r7.l*r6.h), r2.l=(a0=r7.h*r6.h) ; /* simultaneous MAC0
and MAC1 execution, both are signed fractions, both products load
into the Accumulators,MAC1 into half-word registers. */
r4.l=(a0=r1.l*r0.l), r4.h=(a1+=r1.h*r0.h) ; /* same as above,
but sum result into A1. ; MAC order is arbitrary. */
r7.h=(a1+=r6.h*r5.l), r7.l=(a0=r6.h*r5.h) ; /* sum into A1,
subtract into A0 */
r0.h=(a1=r7.h*r4.l) (m), r0.l=(a0+=r7.l*r4.l) ; /* MAC1 multi-
plies a signed fraction by an unsigned fraction. MAC0 multiplies
two signed fractions. */
r5.h=(a1=r3.h*r2.h) (m), r5.l=(a0+=r3.l*r2.l) (fu) ; /* MAC1
multiplies signed fraction by unsigned fraction. MAC0 multiplies
two unsigned fractions. */
r0.h=(a1+=r3.h*r2.h), r0.l=(a0=r3.l*r2.l) (is) ; /* both MACs
perform signed integer multiplication. */
r5.h=(a1=r2.h*r1.h), a0+=r2.l*r1.l ; /* both MACs multiply
signed fractions. MAC0 does not copy the accum result. */
r3.h=(a1=r2.h*r1.h) (m), a0=r2.l*r1.l ; /* MAC1 multiplies
signed fraction by unsigned fraction and uses all 40 bits of A1.
r3.h=a1, r3.l=(a0+=r0.l*r1.l) (s2rnd) ; /* MAC1 copies Accumu-
lator to register half. MAC0 multiplies signed fractions. Both
scale the result and round on the way to the destination regis-
ter. */
r0.l=(a0+=r7.l*r6.l), r0.h=(a1+=r7.h*r6.h) (iss2) ; /* both
MACs process signed integer the way to the destination half-reg-
isters. */

Vector Operations
Result is 32-bit D-register

r3=(a1=r6.h*r7.h), r2=(a0=r6.l*r7.l) ; /* simultaneous MAC0 and
MAC1 execution, both are signed fractions, both products load
into the Accumulators */
r4=(a0=r6.l*r7.l), r5=(a1+=r6.h*r7.h) ; /* same as above, but
sum result into A1. MAC order is arbitrary. */
r7=(a1+=r3.h*r5.h), r6=(a0-=r3.l*r5.l) ; /* sum into A1, sub-
tract into A0 */
r1=(a1=r7.l*r4.l) (m), r0=(a0+=r7.h*r4.h) ; /* MAC1 multiplies
a signed fraction by an unsigned fraction. MAC0 multiplies two
signed fractions. */
r5=(a1=r3.h*r7.h) (m), r4=(a0+=r3.l*r7.l) (fu) ; /* MAC1 multi-
plies signed fraction by unsigned fraction. MAC0 multiplies two
unsigned fractions. */
r1=(a1+=r3.h*r2.h), r0=(a0=r3.l*r2.l) (is) ; /* both MACs per-
form signed integer multiplication */
r5=(a1-=r6.h*r7.h), a0+=r6.l*r7.l ; /* both MACs multiply
signed fractions. MAC0 does not copy the accum result */
r3=(a1=r6.h*r7.h) (m), a0-=r6.l*r7.l ; /* MAC1 multiplies
signed fraction by unsigned fraction and uses all 40 bits of A1.
r3=a1, r2=(a0+=r0.l*r1.l) (s2rnd) ; /* MAC1 moves Accumulator
to register. MAC0 multiplies signed fractions. Both scale the
result and round on the way to the destination register. */
r0=(a0+=r7.l*r6.l), r1=(a1+=r7.h*r6.h) (iss2) ; /* both MACs
process signed integer operands and scale the result on the way
to the destination registers. */

General Form
dest_reg = – source_reg (V)
Syntax
Dreg = – Dreg (V) ; /* dual 16-bit operation (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Vector Negate instruction returns the same magnitude with the
opposite arithmetic sign, saturated for each 16-bit half-word in the source.
The instruction calculates by subtracting the source from zero.
Flags Affected
• AZis set if either or both results are zero; cleared if both are
nonzero.
• ANis set if either or both results are negative; cleared if both are
non-negative.
• V is set if either or both results saturate; cleared if neither saturates.

Vector Operations

• AC0 is set if carry occurs from either or both results; cleared if nei-
ther produces a carry.

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r5 =–r3 (v) ; /* R5.H becomes the negative of R3.H and R5.L
becomes the negative of R3.L If r3 = 0x0004 7FFF the result is r5
= 0xFFFC 8001 */
Also See
None

Vector PACK
General Form
Dest_reg = PACK ( src_half_0, src_half_1 )
Syntax
Dreg = PACK ( Dreg_lo_hi , Dreg_lo_hi ) ; /* (b) */
Syntax Terminology
Dreg: R7–0
Instruction Length
The Vector Pack instruction packs two 16-bit half-word numbers into the
halves of a 32-bit data register as shown in Table 14-18 and Table 14-19.

15..................8 7....................0
src_half_0 half_word_0
src_half_1 half_word_1

31................24 23................16 15..................8 7....................0
dest_reg: half_word_0 half_word_1

Vector Operations
Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
Example
r3=pack(r4.l, r5.l) ; /* pack low / low half-words */
r1=pack(r6.l, r4.h) ; /* pack low / high half-words */
r0=pack(r2.h, r4.l) ; /* pack high / low half-words */
r5=pack(r7.h, r2.h) ; /* pack high / high half-words */
Also See
/* If r4.l = 0xDEAD and r5.l = 0xBEEF, then . . . */
r3 = pack (r4.l, r5.l) ;
/* . . . produces r3 = 0xDEAD BEEF */

Vector SEARCH
General Form
(dest_pointer_hi, dest_pointer_lo ) = SEARCH src_reg (searchmode)
Syntax
(Dreg, Dreg) = SEARCH Dreg (searchmode) ; /* (b) */
Syntax Terminology
Dreg: R7–0
searchmode: (GT), (GE), (LE), or (LT)
Instruction Length
This instruction is used in a loop to locate a maximum or minimum ele-
ment in an array of 16-bit packed data. Two values are tested at a time.
The Vector Search instruction compares two 16-bit, signed half-words to
values stored in the Accumulators. Then, it conditionally updates each
Accumulator and destination pointer based on the comparison.
Pointer register P0 is always the implied array pointer for the elements
being searched.
More specifically, the signed high half-word of src_reg is compared in
magnitude with the 16 low-order bits in A1. If src_reg_hi meets the com-
parison criterion, then A1 is updated with src_reg_hi, and the value in
pointer register P0 is stored in dest_pointer_hi. The same operation is
performed for src_reg_low and A0.

Vector Operations
Based on the search mode specified in the syntax, the instruction tests for
maximum or minimum signed values.
Values are sign extended when copied into the Accumulator(s).
See “Example” for one way to implement the search loop. After the vector
search loop concludes, A1 and A0 hold the two surviving elements, and
dest_pointer_hi and dest_pointer_lo contain their respective addresses.
The next step is to select the final value from these two surviving elements.
Modes
The four supported compare modes are specified by the mandatory
searchmode flag.
Table 14-20. Compare Modes

Mode Description
(GT) Greater than. Find the location of the first maximum number in an array.
(GE) Greater than or equal. Find the location of the last maximum number in an array.
(LT) Less than. Find the location of the first minimum number in an array.
(LE) Less than or equal. Find the location of the last minimum number in an array.
Summary
Assumed Pointer P0
src_reg_hi Compared to least significant 16 bits of A1. If com-
pare condition is met, overwrites lower 16 bits of A1
and copies P0 into dest_pointer_hi.
src_reg_lo Compared to least significant 16 bits of A0. If com-
pare condition is met, overwrites lower 16 bits of A0
and copies P0 into dest_pointer_lo.

Flags Affected
None

ASTAT
on page A-2.
Required Mode
User & Supervisor
Parallel Issue
This instruction can be issued in parallel with the combination of one
16-bit length load instruction to the P0 register and one 16-bit NOP. No
other instructions can be issued in parallel with the Vector Search
instruction.
Example
/* Initialize Accumulators with appropriate value for the type of
search. */
r0.l=0x7fff ;
r0.h=0 ;
a0=r0 ; /* max positive 16-bit value */
a1=r0 ; /* max positive 16-bit value */
/* Initialize R2. */
r2=[p0++] ;
LSETUP (loop, loop) LC0=P1>>2 ; /* set up the loop */
loop: (r1,r0) = SEARCH R2 (LE) || R2=[P0++];
/* search for the last minimum in all but the
last element of the array */
(r1,r0) = SEARCH R2 (LE);
/* finally, search the last element */

Vector Operations
/* The lower 16 bits of A1 and A0 contain the last minimums of the

array. R1 contains the value of P0 corresponding to the value in
A1. R0 contains the value of P0 corresponding to the value in A0.
Next, compare A1 and A0 together and R1 and R0 together to find
the single, last minimum in the array.*/
Note: In this example, the resulting pointers are past the actual
surviving array element due to the post-increment operation. */
cc = (a0 <= a1) ;
r0 += -4 ;
r1 += -2 ;
if !cc r0 = r1 ; /* the pointer to the survivor is in r0 */
Also See
Vector MAX, Vector MIN, MAX, MIN
This instruction is used in a loop to locate an element in a vector accord-
ing to the element’s value.


15 ISSUING PARALLEL
INSTRUCTIONS
This chapter discusses the instructions that can be issued in parallel. It

identifies supported combinations for parallel issue, parallel issue syntax,
32-bit ALU/MAC instructions, 16-bit instructions, and examples.
The Blackfin processor is not superscalar; it does not execute multiple
instructions at once. However, it does permit up to three instructions to
be issued in parallel with some limitations. A multi-issue instruction is
64-bits in length and consists of one 32-bit instruction and two 16-bit
instructions. All three instructions execute in the same amount of time as
the slowest of the three.
Supported Parallel Combinations

The diagram in Table 15-1 illustrates the combinations for parallel issue
that the Blackfin processor supports.
Table 15-1. Parallel Issue Combinations

32-bit ALU/MAC instruction 16-bit Instruction 16-bit Instruction

Parallel Issue Syntax
Parallel Issue Syntax

The syntax of a parallel issue instruction is as follows.
• A 32-bit ALU/MAC instruction || A 16-bit instruction
|| A 16-bit instruction ;
The vertical bar (||) indicates the following instruction is to be

issued in parallel with the previous instruction. Note the terminat-
ing semicolon appears only at the end of the parallel issue
instruction.
It is possible to issue a 32-bit ALU/MAC instruction in parallel
with only one 16-bit instruction using the following syntax. The
result is still a 64-bit instruction with a 16-bit NOP automatically
inserted into the unused 16-bit slot.
• A 32-bit ALU/MAC instruction || A 16-bit instruction ;
Alternately, it is also possible to issue two 16-bit instructions in

parallel with one another without an active 32-bit ALU/MAC
instruction by using the MNOP instruction, shown below. Again, the
result is still a 64-bit instruction.
• MNOP || A 16-bit instruction || A 16-bit instruction ;
See the MNOP (32-bit NOP) instruction description in “No Op” on

page 11-25. The MNOP instruction does not have to be explicitly
included by the programmer; the software tools prepend it auto-
matically. The MNOP instruction will appear in disassembled parallel
16-bit instructions.
32-Bit ALU/MAC Instructions

The list of 32-bit instructions that can be in a parallel instruction are

Issuing Parallel Instructions
Table 15-2. 32-Bit DSP Instructions

Instruction Name Notes
ABS (Absolute Value)
Add Only the versions that support

optional saturation.
Add/Subtract – Prescale Up
Add/Subtract – Prescale Down
EXPADJ (Exponent Detection)
MAX (Maximum)
MIN (Minimum)
Modify – Decrement (for Accumulators, only)
Modify – Increment (for Accumulators, only) Accumulator versions only.
Negate (Two’s Complement) Accumulator versions only.
RND (Round to Half-Word)
Saturate
SIGNBITS
Subtract Saturating versions only.

Bit Operations
DEPOSIT (Bit Field Deposit)
EXTRACT (Bit Field Extract)
BITMUX (Bit Multiplex)
ONES (One’s Population Count)
Logical Operations
^ (Exclusive-OR) (Bit-Wise XOR)

32-Bit ALU/MAC Instructions
Table 15-2. 32-Bit DSP Instructions (Cont’d)

Move
Move Register 40-bit Accumulator versions only.
Move Register Half
Shift / Rotate Operations
Arithmetic Shift Saturating and Accumulator ver-

sions only.
Logical Shift 32-bit instruction size versions

only.
ROT (Rotate)
No Op 32-bit MNOP only


Vector Operations
VIT_MAX (Compare-Select)
Add on Sign
Multiply and Multiply-Accumulate to Accumulator
Multiply and Multiply-Accumulate to Half-Register
Multiply and Multiply-Accumulate to Data Register
Vector ABS (Vector Absolute Value)
Vector Add / Subtract
Vector Arithmetic Shift
Vector MAX (Vector Maximum)
Vector MIN (Vector Minimum)
Vector PACK
Vector SEARCH

16-Bit Instructions

ALIGN8, ALIGN16, ALIGN24 (Byte Align)
DISALGNEXCPT (Disable Alignment Exception for

Load)
Dual 16-Bit Accumulator Extraction with Addition
BYTEOP2P (Quad 8-Bit Average – Half-Word)
BYTEOP3P (Dual 16-Bit Add / Clip)
16-Bit Instructions
The two 16-bit instructions in a multi-issue instruction must each be from
Group1 and Group2 instructions shown in Table 15-3 and Table 15-4.
The following additional restrictions also apply to the 16-bit instructions
of the multi-issue instruction.
• Only one of the 16-bit instructions can be a store instruction.
• If the two 16-bit instructions are memory access instructions, then
both cannot use P-registers as address registers. In this case, at least
one memory access instruction must be an I-register version.

Table 15-3. Group1 Compatible 16-Bit Instructions

Add Immediate Ireg versions only.
Modify – Decrement Ireg versions only.
Modify – Increment Ireg versions only.
Subtract Immediate Ireg versions only.
Load / Store
Load Pointer Register
Load Data Register
Load Half-Word – Zero-Extended
Load Half-Word – Sign-Extended
Load High Data Register Half
Load Low Data Register Half
Store Pointer Register
Store Data Register
Store High Data Register Half

Store Byte

Examples
Table 15-4. Group2 Compatible 16-Bit Instructions

Load / Store
Load Data Register Ireg versions only.
Load High Data Register Half Ireg versions only.
Load Low Data Register Half Ireg versions only.
Store Data Register Ireg versions only.
Store High Data Register Half Ireg versions only.
Store Low Data Register Half Ireg versions only.
No Op 16-bit NOP only.
Examples
Two Parallel Memory Access Instructions
/* Subtract-Absolute-Accumulate issued in parallel with the mem-
ory access instructions that fetch the data for the next SAA
instruction. This sequence is executed in a loop to flip-flop
back and forth between the data in R1 and R3, then the data in R0
and R2. */
saa (r1:0, r3:2) || r0=[i0++] || r2=[i1++] ;
saa (r1:0, r3:2)(r) || r1=[i0++] || r3=[i1++] ;
mnop || r1 = [i0++] || r3 = [i1++] ;
One Ireg and One Memory Access Instruction in Parallel

/* Add on Sign while incrementing an Ireg and loading a data reg-
ister based on the previous value of the Ireg. */
r7.h=r7.l=sign(r2.h)*r3.h + sign(r2.l)*r3.l || i0+=m3 || r0=[i0]
;

/* Add/subtract two vector values while incrementing an Ireg and

loading a data register. */
R2 = R2 +|+ R4, R4 = R2 -|- R4 (ASR) || I0 += M0 (BREV) || R1 =
[I0] ;
/* Multiply and accumulate to Accumulator while loading a data
register and storing a data register using an Ireg pointer. */
A1=R2.L*R1.L, A0=R2.H*R1.H || R2.H=W[I2++] || [I3++]=R3 ;
/* Multiply and accumulate while loading two data registers. One
load uses an Ireg pointer. */
A1+=R0.L*R2.H,A0+=R0.L*R2.L || R2.L=W[I2++] || R0=[I1--] ;
R3.H=(A1+=R0.L*R1.H), R3.L=(A0+=R0.L*R1.L) || R0=[P0++] ||
R1=[I0] ;
/* Pack two vector values while storing a data register using an
Ireg pointer and loading another data register. */
R1=PACK(R1.H,R0.H) || [I0++]=R0 || R2.L=W[I2++] ;
One Ireg Instruction in Parallel

/* Multiply-Accumulate to a Data register while incrementing an
Ireg. */
r6=(a0+=r3.h*r2.h)(fu) || i2-=m0 ;
/* which the assembler expands into:
r6=(a0+=r3.h*r2.h)(fu) || i2-=m0 || nop ; */

Examples

A ADSP-BF535 FLAGS
Table A-1 lists the Blackfin processor instruction set an the affect on flags
when these instructions execute on an ADSP-BF535 DSP. The symbol
definitions for the flag bits in the table are as follows:
• – indicates that the flag is NOT AFFECTED by execution of the
instruction
• * indicates that the flag is SET OR CLEARED depending on exe-
cution of the instruction
• ** indicates that the flag is CLEARED by execution of the
instruction
• U indicates that the flag state is UNDEFINED following execution
of the instruction; if the value of this bit is needed for program exe-
cution, the program needs to check the bit prior executing the
instruction with a U in a bit field.
L The flags with undefined (U) results on the ADSP-BF535 have

defined results on subsequent Blackfin processors.
L Because the AC0, AC1, V, AV0, AV, and VS flags do not exist on
the ADSP-BF535, these flags do not appear in Table A-1.
Blackfin Processor Instruction Set Reference A-1

Table A-1. ASTAT Flag Behavior for the ADSP-BF535
AC0_ V_
Instruction CC AZ AN AQ
COPY COPY
Jump – – – – – –
IF CC JUMP – – – – – –
Call – – – – – –
RTS, RTI, RTX, RTN, RTE (Return) – – – – – –
LSETUP, LOOP – – – – – –
Load Immediate – – – – – –
Load Pointer Register – – – – – –
Load Data Register – – – – – –
Load Half-Word – Zero-Extended – – – – – –
Load Half-Word – Sign-Extended – – – – – –
Load High Data Register Half – – – – – –
Load Low Data Register Half – – – – – –
Load Byte – Zero-Extended – – – – – –
Load Byte – Sign-Extended – – – – – –
Store Pointer Register – – – – – –
Store Data Register – – – – – –
Store High Data Register Half – – – – – –
Store Low Data Register Half – – – – – –
Store Byte – – – – – –
Move Register (except acc to dreg) – – – – – –
– indicates that the flag is NOT AFFECTED by execution of the instruction

* indicates that the flag is SET OR CLEARED depending on execution of the instruction
** indicates that the flag is CLEARED by execution of the instruction
U indicates that the flag state is UNDEFINED following execution of the instruction; if the value of
this bit is needed for program execution, the program needs to check the bit prior executing the
A-2 Blackfin Processor Instruction Set Reference

ADSP-BF535 Flags
Table A-1. ASTAT Flag Behavior for the ADSP-BF535 (Cont’d)

AC0_ V_
COPY COPY
Move Register (acc to dreg) – U U – U –
Move Conditional – – – – – –
Move Half to Full Word – Zero-Extended – * ** ** ** –
Move Half to Full Word – Sign-Extended – * * ** ** –
Move Register Half (except acc to half dreg) – – – – – –
Move Register Half (acc to half dreg) – U U – U –
Move Byte – Zero-Extended – * * ** ** –
Move Byte – Sign-Extended – * * ** ** –
--SP (Push) – – – – – –
--SP (Push Multiple) – – – – – –
SP++ (Pop) – – – – – –
SP++ (Pop Multiple) – – – – – –
LINK, UNLINK – – – – – –
Compare Data Register * * * * U –
Compare Pointer * – – – – –
Compare Accumulator * * * * U –
Move CC – * * * * *
Negate CC * – – – – –
& (AND) – * * ** ** –
~ (NOT One’s Complement) – * * ** ** –


AC0_ V_
COPY COPY
| (OR) – * * ** ** –
^ (Exclusive-OR) – * * ** ** –
BXORSHIFT, BXOR * – – – – –
BITCLR – * * U U –
BITSET – U U U U –
BITTGL – * * U U –
BITTST * – – – – –
DEPOSIT – * * U U –
EXTRACT – * * U U –
BITMUX – U U – – –
ONES (One’s Population Count) – U U – – –
Add with Shift (preg version) – – – – – –
Add with Shift (dreg version) – * * U * –
Shift with Add – – – – – –
Arithmetic Shift (to dreg) – * * U * –
Arithmetic Shift (to A0) – * * U – –
Arithmetic Shift (to A1) – * * U – –
Logical Shift (to preg) – U U U U –
Logical Shift (to dreg) – * * – U –
Logical Shift (to A0) – * * U U –


ADSP-BF535 Flags

AC0_ V_
COPY COPY
Logical Shift (to A1) – * * U U –
ROT (Rotate) * – – – – –
ABS (to dreg) – * ** U * –
ABS (to A0) – * ** U U –
ABS (to A1) – * ** U U –
Add (preg version) – – – – – –
Add (dreg version) – * * * * –
Add/Subtract – Prescale Down – – – – – –
Add/Subtract – Prescale Up – – – – – –
Add Immediate (to preg or ireg) – – – – – –
Add Immediate (to dreg) – * * * * –
DIVS, DIVQ (Divide Primitive) – U U U U *
EXPADJ – U U – – –
MAX – * * U U –
MIN – * * U U –
Modify – Decrement (to preg or ireg) – – – – – –
Modify – Decrement (to acc) – U U U – –
Modify – Increment (to preg or ireg) – – – – – –
Modify – Increment (extracted to dreg) – * * * * –
Modify – Increment (to acc) – U U U U –


AC0_ V_
COPY COPY
Multiply 16-Bit Operands – – – – U –
Multiply 32-Bit Operands – – – – – –
Multiply and Multiply-Accumulate to Accumulator – – – – U –
Multiply and Multiply-Accumulate to Half-Register – – – – U –
Multiply and Multiply-Accumulate to Data Register – – – – U –
Negate (Two’s Complement) (to dreg) – * * U * –
Negate (Two’s Complement) (to A0) – * * U U –
Negate (Two’s Complement) (to A1) – * * U U –
RND (Round to Half-Word) – * * U * –
Saturate – * * U U –
SIGNBITS – U U – – –
Subtract – * * * * –
Subtract Immediate (to ireg) – – – – – –
Idle – – – – – –
Core Synchronize – – – – – –
System Synchronize – – – – – –
EMUEXCPT (Force Emulation) – – – – – –
Disable Interrupts – – – – – –
Enable Interrupts – – – – – –
RAISE (Force Interrupt / Reset) – – – – – –


ADSP-BF535 Flags

AC0_ V_
COPY COPY
EXCPT (Force Exception) – – – – – –
Test and Set Byte (Atomic) * – – – – –
No Op – – – – – –
PREFETCH – – – – – –
FLUSH – – – – – –
FLUSHINV – – – – – –
IFLUSH – – – – – –
ALIGN8, ALIGN16, ALIGN24 – U U – – –
DISALGNEXCPT – – – – – –
BYTEOP3P (Dual 16-Bit Add / Clip) – – – – – –
Dual 16-Bit Accumulator Extraction with Addition – – – – – –
BYTEOP16P (Quad 8-Bit Add) – U U U U –
BYTEOP1P (Quad 8-Bit Average – Byte) – U U U U –
BYTEOP2P (Quad 8-Bit Average – Half-Word) – U U U U –
BYTEPACK (Quad 8-Bit Pack) – U U U U –
BYTEOP16M (Quad 8-Bit Subtract) – U U U U –
SAA (Quad 8-Bit Subtract-Absolute-Accumulate) – U U U U –
BYTEUNPACK (Quad 8-Bit Unpack) – U U U U –
Add on Sign – U U U U –
VIT_MAX (Compare-Select) – U U – – –


AC0_ V_
COPY COPY
Vector ABS – * ** U * –
Vector Add / Subtract – * ** * * –
Vector Arithmetic Shift – * * U * –
Vector Logical Shift – * * U ** –
Vector MAX – * * U ** –
Vector MIN – * * U ** –
Vector Multiply – – – – U –
Vector Multiply and Multiply-Accumulate – – – – * –
Vector Negate (Two’s Complement) – * * * * –
Vector PACK – U U – – –
Vector SEARCH – U U – – –


I INDEX
A Add instructions, continued

ABS mnemonic, 10-3, 14-16 Quad 8-Bit Add, 13-15
Accumulator Vector Add / Subtract, 14-19
corresponding to MACs, 1-8 Add/Subtract - Prescale Down
description, 1-7 instruction, 10-10
extension registers A0.x and A1.x, Add/Subtract - Prescale Up instruction,
4-15 10-13
initializing, 3-4 additional literature, xiv
overflow arithmetic status flags, 1-9 align
saturation, 1-6 ALIGN16 mnemonic, 13-3
Accumulator instructions ALIGN24 mnemonic, 13-3
Accumulator to D-register Move, 4-4 ALIGN8 mnemonic, 13-3
Accumulator to Half D-register allreg, 5-2
Move, 4-16, 4-19 AND instruction, 7-2
Compare Accumulator, 6-9 Arithmetic Logical Unit (ALU)
Dual 16-Bit Accumulator Extraction description summary, 1-8
with Addition, 13-13 Arithmetic Shift instruction, 9-7
Accumulator to D-register Move arithmetic shifts, 9-10, 14-26
instruction, 4-2, 4-4 arithmetic status flags, (see "ASTAT
Accumulator to Half D-register Move register"), 1-9
instruction, 4-19 ASHIFT...BY mnemonic, 9-7, 14-25
Add instructions ASTAT register
Add, 10-6 arithmetic status flags, 1-9, 1-9
Add Immediate, 10-16 V, overflow (D-register), 1-11
Add on Sign, 14-3 RND_MOD bit, 1-14
Add with Shift, 9-2 audience, intended, xiii
Dual 16-Bit Add / Clip, 13-8
Blackfin Processor Instruction Set Reference I-1

INDEX
automatic circular addressing (see BYTEOP2P mnemonic, 13-24

"circular addressing"), 1-15 BYTEOP3P mnemonic, 13-8
average BYTEPACK mnemonic, 13-30
Quad 8-Bit Average – Byte BYTEUNPACK mnemonic, 13-42
instruction, 13-23
Quad 8-Bit Average – Half-Word C
instruction, 13-29 Call instruction, 2-8
CALL mnemonic, 2-8
B choice of one register within a
backgnd_reg, Bit Field Deposit group, notation convention,
instruction, 8-10 1-5
Base Registers (Breg) circular addressing
description, 1-8, 1-16 behavior, 1-15
function in circular addressing, buffer registers
1-16 described, 1-15
instructions that use initializing, 3-11, 3-24, 3-28,
Move Register, 4-2 3-42, 3-46, 3-50, 10-17,
binal point, 1-10 10-38, 10-42, 10-94
bit reverse (BREV) option, 10-40 disabling, 1-8, 1-15, 1-16
BITCLR mnemonic, 8-2 enabling, 1-16
BITMUX mnemonic, 8-21 instructions that support
bits, range of sequential, notation Add Immediate, 1-16, 10-16
convention, 1-5 Load Data Register, 3-11
BITSET mnemonic, 8-4 Load High Data Register Half,
BITTGL mnemonic, 8-6 3-24
BITTST mnemonic, 8-8 Load Low Data Register Half,
branching, 2-5 to 2-7 3-28
buffer, flushing the core buffer, 11-5 Modify – Decrement, 1-16,
BXOR mnemonic, 7-10 10-38
BXORSHIFT mnemonic, 7-10 Modify – Increment, 10-42
Byte Align instruction, 13-3 Store Data Register, 3-41
BYTEOP16M mnemonic, 13-33 Store High Data Register Half,
BYTEOP16P mnemonic, 13-15 3-46
BYTEOP1P mnemonic, 13-19
I-2 Blackfin Processor Instruction Set Reference

INDEX
circular addressing, continued constants, continued

Store Low Data Register Half, uimm6m4, 3-7, 3-11, 3-37, 3-41
3-50 uimm7m4, 3-7, 3-11, 3-37, 3-41
Subtract Immediate, 10-93 constants, notation convention, 1-5,
CLI mnemonic, 11-13 1-6
compare instructions conventions, xxii
Compare Accumulator, 6-9 Core Synchronize instruction, 11-5
Compare Data Register, 6-2 count instructions
Compare Pointer, 6-6 Ones Population Count, 8-26
Compare-Select (VIT_MAX), CSYNC mnemonic, 11-5
14-9 customer support, xv
constants
imm16, 3-4 D
imm3, 6-2, 6-6 dagreg, 4-3
imm6, 9-21 Data Address Generator (DAG)
imm7, 3-4, 10-16 description summary, 1-8
lppcrel11m2, 2-14 Data Registers (Dreg)
pcrel11m2, 2-6 description, 1-7
pcrel13m2, 2-2 decimal point, 1-10
pcrel25m2, 2-3, 2-8 DEPOSIT mnemonic, 8-10
pcrel5m2, 2-14 DISALGNEXCPT mnemonic,
pcrelm2, 2-2 13-6
uimm15, 3-31, 3-34, 3-54 Divide Primitive instruction, 10-19
uimm16, 3-4 DIVQ mnemonic, 10-19
uimm16m2, 3-15, 3-19, 3-50 DIVS mnemonic, 10-19
uimm17m4, 3-7, 3-11, 3-37, Dreg_even, 4-3, 10-70
3-41 Dreg_hi, 3-45, 4-16, 10-46, 10-61,
uimm18m4, 5-17 14-3
uimm3, 6-2, 6-6 Dreg_lo, 3-27, 3-49, 4-10, 4-13,
uimm4, 9-8, 9-15, 11-17, 11-20, 4-16, 7-10, 8-16, 8-26, 9-8,
14-25, 14-30 9-15, 10-27, 10-46, 10-61,
uimm5, 8-2, 8-4, 8-6, 8-8, 9-8, 10-86, 14-3, 14-9, 14-25,
9-15 14-30
uimm5m2, 3-15, 3-19, 3-50

INDEX
Dreg_lo_hi, 9-8, 9-15, 10-6, 10-10, exceptions, continued

10-13, 10-27, 10-41, 10-46, resolved during synchronization,
10-56, 10-61, 10-70, 10-80, 11-5, 11-6, 11-9
10-86, 10-89, 14-50 resolving before TESTSET
Dreg_odd, 4-3, 10-70 operation begins, 11-24
resolving before TESTSET
E operation completes, 11-23
EMUEXCPT mnemonic, 11-11 return from (RTX), 2-10, 2-11
emulation undefined instruction, 3-8, 5-3
Force Emulation instruction, Exclusive-OR instruction, 7-8
11-11 EXCPT mnemonic, 11-20
exceptions EXPADJ mnemonic, 10-27
address violations not flagged, EXTRACT mnemonic, 8-16
12-2 to 12-8
alignment, 2-3, 3-8 to 3-50, 5-3, F
5-7, 5-10, 5-15, 5-19 Flags, ADSP-21535, A-1
alignment errors prevented, 13-6 Flags, ADSP-BF535, A-2
to 13-42 FLUSH mnemonic, 12-4
emulation, 11-11 FLUSHINV mnemonic, 12-6
Force Exception (EXCPT) Force Emulation instruction, 11-11
instruction, 11-20 Force Exception instruction, 11-20
graceful instruction abort, 5-6, Force Interrupt / Reset instruction,
5-15, 5-18 11-17
handler routine, 11-20 foregnd_reg, Bit Field Deposit
illegal instruction, 11-11 instruction, 8-10
not invoked by Force Interrupt / fractions
Reset instruction, 11-18 binal point, 1-10
not masked by Disable Interrupts binary convention, 1-10
instruction, 11-13 Frame Pointer
protection violation, 2-11, 4-5, description, 1-7
5-3, 5-10, 11-4, 11-13, 11-15, frame pointer, 3-8, 3-12, 3-38, 5-17
11-19
protection violations not flagged, G
12-2, 12-4, 12-6, 12-8 genreg, 4-3

INDEX
I
Idle instruction, 11-3, 11-14, 11-16 interrupts
IDLE mnemonic, 11-3 disabling
IF CC JUMP mnemonic, 2-5 Disable Interrupts (CLI) in-
IF CC mnemonic, 4-8 struction, 11-13
IFLUSH mnemonic, 12-8 popping RETI from stack, 5-3
ILAT register, 11-20 enabling
imm16 constant, 3-4 Enable Interrupts (STI) instruc-
imm3 constant, 6-2, 6-6 tion, 11-15
imm6 constant, 9-21 forcing
imm7 constant, 3-4, 10-16 Force Interrupt / Reset (RAISE)
immediate constant, 1-5 instruction, 11-17
Index Registers (Ireg) NMI, return from (RTN), 2-10
description, 1-7, 1-15 priority, 11-17
function in circular addressing, return instruction (RTI), 2-10
1-15 uninterruptable instructions
instructions that use linkage instruction, LINK, UN-
Add Immediate, 10-16 LINK, 5-18
Load Data Register, 3-10 Pop Multiple, 5-15
Load High Data Register Half, Push Multiple, 5-6
3-23, 3-27 Return from Interrupt (RTI),
Modify – Decrement, 10-37 2-11
Modify – Increment, 10-40 Return from NMI (RTN), 2-11
Move Register, 4-2 Test and Set Byte (Atomic)
Store Data Register, 3-40 TESTSET, 11-23
Store High Data Register Half, vector, 11-17
3-45
Store Low Data Register Half, J
3-49 jump instructions
Subtract Immediate, 10-93 Conditional Jump, 2-5
Interrupt Mask (IMASK) register, Jump, 2-2
11-15 JUMP mnemonic, 2-2

INDEX
L Loop Count registers (LC0, LC1)

Length Registers (Lreg) description, 1-7
description, 1-8, 1-16 loop PC-relative constant, 1-6
function in circular addressing, Loop Top registers (LT0, LT1)
1-16 description, 1-7
instructions that use lppcrel11m2 constant, 2-14
Move Register, 4-2 LSETUP mnemonic, 2-13
LINK mnemonic, 5-17 LSHIFT...BY mnemonic, 9-14,
Link, unlink instruction, 5-17 14-30
Load Data Register instruction,
3-10 M
load instructions MAC1 Multiply and Accumulate
Load Byte – Sign-Extended, 3-34 Unit 1
Load Byte – Zero-Extended, 3-31 mixed mode option (M), 10-51,
Load Half-Word – 10-58, 10-67, 10-73
Sign-Extended, 3-19 manual
Load Half-Word – audience, xiii
Zero-Extended, 3-15 contents, xiv
Load High Data Register Half, conventions, xxii
3-23 new in this edition, xiv
Load Immediate, 3-3 related documents, xviii
Load Low Data Register Half, MAX mnemonic, 10-31, 14-34
3-27 maximum instructions
Load Pointer Register, 3-7 Vector Maximum, 14-34
Logical Shift instruction, 9-14 MIN mnemonic, 10-34, 14-37
loop minimum instructions
Loop Bottom register, 4-6 Vector Minimum, 14-37
Loop Count register, 4-6 mixed mode option (M), 10-46,
LOOP mnemonic, 2-13 10-51, 10-58, 10-67, 10-73
Loop Top register, 4-6 mnemonic
Zero - Overhead Loop Setup ABS, 10-3, 14-16
instruction, 2-13 ALIGN16, 13-3
Loop Bottom registers (LB0, LB1) ALIGN24, 13-3
description, 1-7 ALIGN8, 13-3

INDEX
mnemonic, continued mnemonic, continued

ASHIFT...BY, 9-7, 14-25 LINK, 5-17
BITCLR, 8-2 LOOP, 2-13
BITMUX, 8-21 LSETUP, 2-13
BITSET, 8-4 LSHIFT...BY, 9-14, 14-30
BITTGL, 8-6 MAX, 10-31, 14-34
BITTST, 8-8 MIN, 10-34, 14-37
BXOR, 7-10 NOP, 11-25
BXORSHIFT, 7-10 ONES, 8-26
BYTEOP16M, 13-33 PACK, 14-50
BYTEOP16P, 13-15 PREFETCH, 12-2
BYTEOP1P, 13-19 RAISE, 11-17
BYTEOP2P, 13-24 RND, 10-80
BYTEOP3P, 13-8 RND12, 10-13
BYTEPACK, 13-30 RND20, 10-10
BYTEUNPACK, 13-42 ROT...BY, 9-21
CALL, 2-8 RTE, 2-10
CLI, 11-13 RTI, 2-10
CSYNC, 11-5 RTN, 2-10
DEPOSIT, 8-10 RTS, 2-10
DISALGNEXCPT, 13-6 RTX, 2-10
DIVQ, 10-19 SAA, 13-37
DIVS, 10-19 SEARCH, 14-52
EMUEXCPT, 11-11 SIGN, 14-3
EXCPT, 11-20 SIGNBITS, 10-86
EXPADJ, 10-27 SSYNC, 11-8
EXTRACT, 8-16 STI, 11-15
FLUSH, 12-4 TESTSET, 11-22
FLUSHINV, 12-6 UNLINK, 5-17
IDLE, 11-3 VIT_MAX, 14-9
IF CC, 4-8 MNOP used in parallel instruction
IF CC JUMP, 2-5 issues, 15-2, 15-8
IFLUSH, 12-8
JUMP, 2-2

INDEX
modify instructions Multiply 32-Bit Operands

Modify – Decrement, 10-37 instruction, 10-54
Modify – Increment, 10-40 Multiply and Accumulate Unit
Modify Registers (Mreg) (MAC)
description, 1-7 combining MAC0 and
function in circular addressing, MAC1operations in vector
1-15 instructions, 14-40, 14-43
instructions that use description summary, 1-8
Load Data Register, 3-10 Multiply and Accumulate Unit 1
Modify – Decrement, 10-37 (MAC1)
Modify – Increment, 10-40 mixed mode option (M), 10-46,
Move Register, 4-2 10-51, 10-58, 10-67, 10-73,
Store Data Register, 3-40 14-40, 14-43
used to increment Ireg, 1-15 Multiply and Multiply-Accumulate
mostreg, 5-8 to Accumulator instruction,
Move Byte – Zero-Extended 10-56
instruction, 4-23 Multiply and Multiply-Accumulate
Move Conditional instruction, 6-12 to Data Register instruction,
Move Half to Full Word – 10-70
Sign-Extended instruction, Multiply and Multiply-Accumulate
4-10 to Half-Register instruction,
Move Half to Full Word – 10-61
Zero-Extended instruction, multiply instructions
4-13 Vector Multiply, 14-40
move instructions Vector Multiply and
Move Byte – Sign-Extended, 4-25 Multiply-Accumulate, 14-43
Move Conditional, 4-8
Move Register Half instruction, N
4-15 Negate (Two’s Complement)
Move Register instruction, 4-2 instruction, 10-76
Mreg, instructions that use negate instructions
Store Data Register, 3-40 Negate CC, 6-15
Multiply 16-Bit Operands Vector Negate, 14-48
instruction, 10-46 No Op instruction, 11-25

INDEX
NOP mnemonic, 11-25 << logical left shift, 9-2, 9-5, 9-7,
NOT (1’s Complement) 9-14, 14-25, 14-30
instruction, 7-4 <<= logical left shift assign, 9-14
notation conventions, 1-4 <= less-than or equal, 6-2, 6-6, 6-9
choice of one register within a = assign (representative sample,
group, 1-5 only), 3-3, 4-2, 5-2, 6-12, 7-10,
constants, 1-5 8-8, 9-2, 10-3, 13-3, 14-3
loop PC-relative constants, 1-6 =– negate (2’s complement)
PC-relative constants, 1-5 assign, 10-76, 14-48
range of sequential registers or –= subtract assign, 10-37, 10-56,
bits, 1-5 10-61, 10-70, 10-93
=! bit invert (one’s complement)
O assign, 6-15, 8-8
ONES mnemonic, 8-26 == compare-equal, 6-2, 6-6, 6-9
Ones Population Count =~ multi-bit invert (one’s
instruction, 8-26 complement) assign, 7-4
operator >> logical right shift, 9-14, 14-30
– – autodecrement, 5-2, 5-5 >>= logical right shift assign, 9-14
– subtract, 10-10, 10-13, 10-89, >>> arithmetic right shift, 9-7,
14-19 14-25
& logical AND, 7-2 >>>= arithmetic right shift assign,
&= logical AND assign, 6-12 9-7
* multiply, 10-46, 10-56, 10-61, ^ logical XOR, 7-8
10-70, 14-3 ^= logical XOR assign, 6-12
+ add, 9-5, 10-6, 10-10, 10-13, | logical OR, 7-6
13-13, 14-19 –|– vector subtract / subtract,
++ autoincrement, 5-8, 5-12, 14-19
12-6, 12-8 –|+ vector subtract / add, 14-19
+= add assign, 10-16, 10-40, |= logical OR assign, 6-12
10-56, 10-61, 10-70 option flags
+|– vector add / subtract, 14-19 16-bit Accumulator extraction
+|+ vector add / add, 14-19 with x2 scaling, 16-bit
< less-than, 6-2, 6-6, 6-9 saturation and rounding
(S2RND)

INDEX
option flags, continued option flags, continued

Multiply 16-Bit Operands in- bit reverse (BREV)
struction, 10-46 Modify – Increment instruc-
Multiply and Multiply-Accu- tion, 10-40
mulate to Data Register in- cross outputs (CO)
struction, 10-70 Vector Add / Subtract instruc-
Multiply and Multiply-Accu- tion, 14-19
mulate to Half-Register in- fraction, unsigned operator (FU)
struction, 10-70 Multiply 16-Bit Operands in-
use with move instructions, struction, 10-46
4-16 Multiply and Multiply-Accu-
use with multiply instructions, mulate to Accumulator in-
10-46, 10-61, 10-70 struction, 10-56
32-bit Accumulator extraction Multiply and Multiply-Accu-
with x2 scaling and 32-bit mulate to Data Register in-
saturation (ISS2) struction, 10-70
Multiply 16-Bit Operands in- Multiply and Multiply-Accu-
struction, 10-46 mulate to Half-Register in-
Multiply and Multiply-Accu- struction, 10-61
mulate to Data Register in- use with multiply instructions,
struction, 10-70 10-46, 10-56, 10-61, 10-70
Multiply and Multiply-Accu- high half-word Accumulator
mulate to Half-Register in- extraction with saturation and
struction, 10-61 rounding (IH)
use with move instructions, Multiply 16-Bit Operands in-
4-16 struction, 10-46
use with multiply instructions, Multiply and Multiply-Accu-
10-46, 10-61, 10-70 mulate to Half-Register in-
arithmetic shift left (ASL) struction, 10-61
use with instructions, 8-21, use with instructions, 4-16,
14-9, 14-19 10-46, 10-61
arithmetic shift right (ASR) integer, signed operator (IS)
use with instructions, 8-21, Multiply 16-Bit Operands in-
14-9, 14-19 struction, 10-46

INDEX
option flags, continued option flags, continued

Multiply and Multiply-Accu- Negate (Two’s Complement)
mulate to Accumulator in- instruction, 10-76
struction, 10-56 Subtract instruction, 10-89
Multiply and Multiply-Accu- saturate (S)
mulate to Data Register in- Add instruction, 10-6
struction, 10-70 Arithmetic Shift instruction,
Multiply and Multiply-Accu- 9-7
mulate to Half-Register in- Negate (Two’s Complement)
struction, 10-61 instruction, 10-76
use with move instructions, Saturate instruction, 10-83
4-16 Subtract instruction, 10-89
use with multiply instructions, Vector Add / Subtract instruc-
10-46, 10-56, 10-61, 10-70 tion, 14-19
integer, unsigned operator (IU) saturate Accumulator at 32-bit
Multiply 16-Bit Operands in- word boundary (W32)
struction, 10-46 Multiply and Multiply-Accu-
Multiply and Multiply-Accu- mulate to Accumulator in-
mulate to Half-Register instruction, 10-56
struction, 10-61 use with modify instructions,
use with compare instructions, 10-37, 10-40
6-2, 6-6 use with multiply instructions,
use with move instructions, 10-56
4-16 saturate and cross outputs (SCO)
use with multiply instructions, Vector Add / Subtract instruc-
10-46, 10-61 tion, 14-19
mixed mode (M) sign extended (X)
Vector Multiply and Multi- use with bit field instructions,
ply-Accumulate instruction, 8-10, 8-16
14-43 use with load instructions, 3-3,
Vector Multiply instruction, 3-19, 3-34
14-40 use with move instructions,
no saturate (NS) 4-13, 4-25
Add instruction, 10-6 truncate (T)

INDEX
option flags, continued overflow, continued

Move Register Half instruction, impossible in the Multiply 32-Bit
4-16 Operands instruction, 10-54
Quad 8-Bit Average – Byte in- prevention in Divide Primitive
struction, 13-19 instruction, 10-22
truncate, signed fraction operands
(T) P
Multiply 16-Bit Operands in- PACK mnemonic, 14-50
struction, 10-46 packing instructions
Multiply and Multiply-Accu- Quad 8-Bit Pack, 13-30
mulate to Half-Register in- Quad 8-Bit Unpack, 13-48
struction, 10-61 Vector Pack, 14-50
use with multiply instructions, pattern_reg, Bit Field Extraction
10-46, 10-61 instruction, 8-16
truncate, unsigned fraction pcrel11m2 constant, 2-6
operands (TFU) pcrel13m2 constant, 2-2
Multiply 16-Bit Operands in- pcrel25m2 constant, 2-3, 2-8
struction, 10-46 pcrel5m2constant, 2-14
Multiply and Multiply-Accu- PC-relative constant, 1-5
mulate to Half-Register in- pcrelm2 constant, 2-2
struction, 10-61 pointer registers, 3-11, 3-20, 3-47
use with multiply instructions, Pointer Registers (Preg)
10-46, 10-61 description, 1-7
zero extended (Z) Pop instruction, 5-8
use with instructions, 3-3, 3-15, Pop Multiple instruction, 5-12
3-31, 4-10, 4-23, 8-16 PREFETCH mnemonic, 12-2
OR instructions Push instruction, 5-2
Exclusive-OR, 7-8 Push Multiple instruction, 5-5
OR, 7-6
overflow Q
arithmetic status flags, 1-9, 1-11
Quad 8-Bit Add instruction, 13-15
behavior, 1-11, 1-12
Quad 8-Bit Average – Byte
implemented by user for the
instruction, 13-23
instruction, 10-54

INDEX
Quad 8-Bit Average – Half-Word RND12 mnemonic, 10-13

instruction, 13-29 RND20 mnemonic, 10-10
Quad 8-Bit Pack instruction, 13-30 ROT...BY mnemonic, 9-21
Quad 8-Bit Subtract instruction, Rotate instruction, 9-21
13-33 Round to Half-Word instruction,
Quad 8-Bit 10-80
Subtract-Absolute-Accumulate rounding
instruction, 13-37 behavior, 1-14
Quad 8-Bit Unpack instruction, biased, 1-13
13-48 convergent, 1-13
round-to-nearest, 1-13
R unbiased, 1-13
RAISE mnemonic, 11-17 RTE mnemonic, 2-10
reg, 3-4 RTI mnemonic, 2-10
register pairs RTN mnemonic, 2-10
valid pairs defined, 1-4 RTS mnemonic, 2-10
register portions RTX mnemonic, 2-10
notation convention, 1-4
register set notation S
multiple Data Registers in one SAA mnemonic, 13-37
instruction, 1-4 saturation
registers, choice of one register 16-bit register range, 1-12
within a group, notation 32-bit register range, 1-12
convention, 1-5 40-bit register range, 1-12
registers, range of sequential, Accumulator, 1-6
notation convention, 1-5 Saturate instruction, 10-83
related documents, xviii scalar operations, 14-40, 14-43
RETS register, 2-9, 5-3, 5-17 scene_reg, Bit Field Extraction
Return instruction, 2-10 instruction, 8-16
RND mnemonic, 10-80 SEARCH mnemonic, 14-52
RND_MOD bit search, Vector Search instruction,
affected instructions, 4-18, 10-41, 14-52
10-48, 10-62 SEQSTAT register, 11-3, 11-8
located in ASTAT register, 1-14

INDEX
sequential registers or bits, range of, subtract instructions

notation convention, 1-5 Quad 8-Bit Subtract, 13-33
shift instructions Quad 8-Bit
Arithmetic Shift, 9-7 Subtract-Absolute-Accumulate,
Logical Shift, 9-14 13-37
Shift with Add, 9-5 Subtract, 10-89
Vector Arithmetic Shift, 14-25 Subtract Immediate, 10-93
Vector Logical Shift, 14-30 Vector Add / Subtract, 14-19
SIGN mnemonic, 14-3 superscalar architecture, 15-1
SIGNBITS mnemonic, 10-86 Supervisor mode
SSYNC mnemonic, 11-8 exclusive Supervisor instructions
stack Disable Interrupts, 11-13
effects of Linkage instruction, Enable Interrupts, 11-15
5-18 Force Interrupt / Reset, 11-19
effects of Pop instruction, 5-9 Idle, 11-4
effects of Pop Multiple Return (RTI, RTX, and RTN),
instruction, 5-13 2-11
effects of Push instruction, 5-2 exclusive Supervisor registers
effects of Push Multiple RETE, 4-5, 5-3, 5-10
instruction, 5-6 RETI, 4-5, 5-3, 5-10
maximum frame size, 5-18 RETN, 4-5, 5-3, 5-10
Stack Pointer, 1-7, 5-7 to 5-19 RETX, 4-5, 5-3, 5-10
STI mnemonic, 11-15 SEQSTAT, 4-5, 5-3, 5-10
store instructions SYSCFG, 4-5, 5-3, 5-10
Store Byte, 3-54 USP, 4-5, 5-3, 5-10
Store Data Register, 3-40 support, technical or customer, xv
Store High Data Register Half, Synchronize, Core instruction, 11-5
3-45 syntax
Store Low Data Register Half, allreg, 5-2
3-49 case insensitive, 1-2
Store Pointer Register, 3-37 comment delineators, 1-3
constants
imm16, 3-4
imm3, 6-2, 6-6

INDEX
syntax, constants, continued syntax, continued

imm6, 9-21 Dreg_lo, 3-27, 3-49, 4-10, 4-13,
imm7, 3-4, 10-16 4-16, 7-10, 8-16, 8-26, 9-8,
lppcrel11m2, 2-14 9-15, 10-27, 10-46, 10-61,
notation convention, 1-5, 1-6 10-86, 14-3, 14-9, 14-25,
pcrel11m2, 2-6 14-30
pcrel13m2, 2-2 Dreg_lo_hi, 9-8, 9-15, 10-6,
pcrel25m2, 2-3, 2-8 10-10, 10-13, 10-27, 10-41,
pcrel5m2, 2-14 10-46, 10-56, 10-61, 10-70,
pcrelm2, 2-2 10-80, 10-86, 10-89, 14-50
uimm15, 3-31, 3-34, 3-54 Dreg_odd, 4-3, 10-70
uimm16, 3-4 free format, 1-2
uimm16m2, 3-15, 3-19, 3-50 genreg, 4-3
uimm17m4, 3-7, 3-11, 3-37, instruction delimiting, 1-2
3-41 mostreg, 5-8
uimm18m4, 5-17 reg, 3-4
uimm3, 6-2, 6-6 sysreg, 4-3
uimm4, 9-8, 9-15, 11-17, user label, 2-3, 2-6, 2-8
11-20, 14-25, 14-30 sysreg, 4-3
uimm5, 8-2, 8-4, 8-6, 8-8, 9-8, System Synchronize instruction,
9-15 11-8
uimm5m2, 3-15, 3-19, 3-50
uimm6m4, 3-7, 3-11, 3-37, T
3-41 technical support, xv
uimm7m4, 3-7, 3-11, 3-37, test instructions
3-41 Test and Set Byte (Atomic), 11-22
constants, notation convention, TESTSET mnemonic, 11-22
1-5 truncation
dagreg, 4-3 behavior, 1-14
Dreg_even, 4-3, 10-70 results in large bias, 1-14
Dreg_hi, 3-45, 4-16, 10-46,
10-61, 14-3 U
uimm15 constant, 3-31, 3-34, 3-54
uimm16 constant, 3-4

INDEX
uimm16m2 constant, 3-15, 3-19, Vector Negate (Two’s

3-50 Complement) instruction,
uimm17m4 constant, 3-7, 3-11, 14-48
3-37, 3-41 video bit field operations
uimm18m4 constant, 5-17 Bit Field Deposit instruction
uimm3 constant, 6-2, 6-6 backgnd_reg, 8-10
uimm4 constant, 9-8, 9-15, 11-17, foregnd_reg, 8-10
11-20, 14-25, 14-30 Bit Field Extraction instruction
uimm5 constant, 8-2, 8-4, 8-6, 8-8, pattern_reg, 8-16
9-8, 9-15 scene_reg, 8-16
uimm5m2 constant, 3-15, 3-19, VIT_MAX mnemonic, 14-9
3-50
uimm6m4 constant, 3-7, 3-11, Z
3-37, 3-41 Zero-Overhead Loop Setup
uimm7m4 constant, 3-7, 3-11, instruction, 2-13
3-37, 3-41
UNLINK mnemonic, 5-17
user_label, 2-3, 2-6, 2-8
V
vector couplet, 14-40, 14-43
vector instructions
Vector Absolute Value, 14-16
Vector Add / Subtract, 14-19
Vector Arithmetic Shift, 14-25
Vector Logical Shift, 14-30
Vector Maximum, 14-34
Vector Minimum, 14-37
Vector Multiply, 14-40
Vector Multiply and
Multiply-Accumulate, 14-43
Vector Pack, 14-50
Vector Search, 14-52

Blackfin® Processor Instruction Set

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

Blackfin® Processor Instruction Set

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Blackfin® Processor Instruction Set

Uploaded by

Copyright:

Available Formats

Blackfin® Processor

Instruction Set Reference

Revision 3.0, June 2004

Analog Devices, Inc.

Printed in the USA.

Trademark and Service Mark Notice

Blackfin Processor Instruction Set Reference iii

Syntax Conventions ...................................................................... 1-1

PROGRAM FLOW CONTROL

iv Blackfin Processor Instruction Set Reference

Blackfin Processor Instruction Set Reference v

Move Byte – Zero-Extended ....................................................... 4-23

CONTROL CODE BIT MANAGEMENT

vi Blackfin Processor Instruction Set Reference

Blackfin Processor Instruction Set Reference vii

Add Immediate ......................................................................... 10-16

EXTERNAL EVENT MANAGEMENT

viii Blackfin Processor Instruction Set Reference

Disable Interrupts ..................................................................... 11-13

VIDEO PIXEL OPERATIONS

Blackfin Processor Instruction Set Reference ix

SAA (Quad 8-Bit Subtract-Absolute-Accumulate) ...................... 13-37

ISSUING PARALLEL INSTRUCTIONS

x Blackfin Processor Instruction Set Reference

Blackfin Processor Instruction Set Reference xi

xii Blackfin Processor Instruction Set Reference

Purpose of This Manual

Blackfin Processor Instruction Set Reference xiii

What’s New in This Manual

xiv Blackfin Processor Instruction Set Reference

Technical or Customer Support

• E-mail tools questions to

• E-mail processor questions to

• Phone questions to 1-800-ANALOGD

Blackfin Processor Instruction Set Reference xv

xvi Blackfin Processor Instruction Set Reference

Processor Product Information

Blackfin Processor Instruction Set Reference xvii

• Fax questions or requests for information to

xviii Blackfin Processor Instruction Set Reference

Online Technical Documentation

.CHM Help system files and manuals in Help format

If documentation is not installed on your system as part of the software

Accessing Documentation From VisualDSP++

Blackfin Processor Instruction Set Reference xix

Accessing Documentation From Windows

Accessing Documentation From the Web

xx Blackfin Processor Instruction Set Reference

VisualDSP++ Documentation Set

Hardware Tools Manuals

Blackfin Processor Instruction Set Reference xxi

this|that Alternative items in syntax descriptions are delimited with a vertical

filename Non-keyword placeholders appear in text with italic style format.

This symbol indicates a note that provides supplementary information

This symbol indicates a warning that advises on an inappropriate usage

xxii Blackfin Processor Instruction Set Reference

L Additional conventions, which apply only to specific chapters, may

Blackfin Processor Instruction Set Reference xxiii

xxiv Blackfin Processor Instruction Set Reference