Assembly Programming Manual

The XMOS assembly language supports the formation of objects in the Executable and Linkable Format (ELF) with DWARF 3 debugging information. Extensions to the ELF format are documented in the XMOS Application Binary Interface.

Lexical Conventions

There are six classes of tokens: symbol names, directives, constants, operators, instruction mnemonics and other separators. Blanks, tabs, formfeeds and comments are ignored except as they separate tokens.

Comments

The character # introduces a comment, which terminates with a newline. Comments do not occur within string literals.

Symbol Names

A symbol name begins with a letter or with one of the characters ‘.‘, ‘_‘ or ‘$‘, followed by an optional sequence of letters, digits, periods, underscores and dollar signs. Upper and lower case letters are different.

Directives

A directive begins with ‘.‘ followed by one or more letters. Directives instruct the assembler to perform some action (see Directives).

Constants

A constant is either an integer number, a character constant or a string literal.

  • A binary integer is 0b or 0B followed by zero or more of the digits 01.
  • An octal integer is 0 followed by zero or more of the digits 01234567.
  • A decimal integer is a non-zero digit followed by zero or more of the digits 0123456789.
  • A hexadecimal integer is 0x or 0X followed by one or more of the digits and letters 0123456789abcdefABCDEF.
  • A character constant is a sequence of characters surrounded by single quotes.
  • A string literal is a sequence of characters surrounded by double quotes.

The C escape sequences may be used to specify certain characters.

Sections and Relocations

Named ELF sections are specified using directives (see section, pushsection, popsection). In addition, there is a unique unnamed “absolute” section and a unique unnamed “undefined” section. The notation {secname X} refers to an “offset X into section secname.”

The values of symbols in the absolute section are unaffected by relocations. For example, address {absolute 0} is “relocated” to run-time address 0. The values of symbols in the undefined section are not set.

The assembler keeps track of the current section. Initially the current section is set to the text section. Directives can be used to change the current section. Assembly instructions and directives which allocate storage are emitted in the current section. For each section, the assembler maintains a location counter which holds the current offset in the section. The active location counter refers to the location counter for the current section.

Symbols

Each symbol has exactly one name; each name in an assembly program refers to exactly one symbol. A local symbol is any symbol beginning with the characters “.L”. A local symbol may be discarded by the linker when no longer required for linking.

Attributes

Each symbol has a value, an associated section and a binding. A symbol is assigned a value using the set or linkset directives (see set, linkset), or through its use in a label (see Labels). The default binding of symbols in the undefined section is global; for all other symbols the default binding is local.

Labels

A label is a symbol name immediately followed by a colon (:). The symbol’s value is set to the current value of the active location counter. The symbol’s section is set to the current section. A symbol name must not appear in more than one label.

Expressions

An expression specifies an address or value. The result of an expression must be an absolute number or an offset into a particular section. An expression is a constant expression if all of its symbols are defined and it evaluates to a constant. An expression is a simple expression if it is one of a constant expression, a symbol, or a symbol ± a constant. An expression may be encoded in the ELF-extended expression section and its value evaluated by the linker (see set, linkset); the encoding scheme is determined by the ABI. The syntax of an expression is:

expression ::= unary-exp
| expression infix-op unary-exp
| unary-exp ? unary-exp $: unary-exp
| function-exp
unary-exp ::= argument
| prefix-op unary-exp
argument ::= symbol
| constant
| ( expression )
function-exp ::= $overlay_region_ptr ( symbol )
| $overlay_index ( symbol )
| $overlay_physical_addr ( symbol )
| $overlay_virtual_addr ( symbol )
| $overlay_num_bytes ( symbol )
infix-op ::= one of
+ - < > <= >= || << >> * $M $A & /
prefix-op ::= one of
- ~ $D

Symbols are evaluated to {section x} where section is one of a named section, the absolute section or the undefined section, and x is a signed 2’s complement 32-bit integer.

Infix operators have the same precedence and behavior as C, and operators with equal precedence are performed left to right. In addition, the $M operator has lowest precedence, and the $A operator has the highest precedence.

For the + and - operators, the set of valid operations and results is given in the table below. For the $D operator, the argument must be a symbol; the result is 1 if the symbol is defined and 0 otherwise.

Valid operations for + and - operators

Op

Left Operand

Right Operand

Result

+

{section x}

{absolute y}

{section x+y}

+

{absolute x}

{section y}

{section x+y}

+

{absolute x}

{absolute y}

{absolute x+y}

-

{section x}

{section y}

{absolute x-y}

-

{section x}

{absolute y}

{section x-y}

-

{absolute x}

{absolute y}

{absolute x-y}

The ? operator is used to select between symbols: if the first operand is non-zero then the result is the second operand, otherwise the result is the third operand.

The operators $overlay_region_ptr, $overlay_index, $overlay_physical_addr, $overlay_virtual_addr and $overlay_num_bytes can be used to query properties of the overlay containing the overlay roots with the specified overlay key symbol (see Overlay Directives). The set of results of these operators is given in the table below.

Operators for querying properties of overlays.

Operator

Result

$overlay_region_ptr

Virtual address of the overlay region containing the overlay.

$overlay_index

Index of the overlay in the overlay region.

$overlay_physical_addr

Physical address of the overlay.

$overlay_virtual_addr

Virtual (runtime) address of the overlay.

$overlay_num_bytes

Size of the overlay in bytes.

For all other operators, both arguments must be absolute and the result is absolute. The $M operator returns the maximum of the two operands and the $A operator returns the value of the first operand aligned to the second.

Wherever an absolute expression is required, if omitted then {absolute 0} is assumed.

Directives

Directives instruct the assembler to perform some action. The supported directives are given in this section.

add_to_set

The add_to_set directive adds an expression to a set of expressions associated with a key symbol. Its syntax is:

add-to-set-directive ::= .add_to_set symbol , expression
| .add_to_set symbol , expression , symbol

An optional predicate symbol may be specified as the 3rd argument. If this argument is specified the expression will only be added to the set if the predicate symbol is not eliminated from the linked object.

max_reduce, sum_reduce

The max_reduce directive computes the maximum of the values of the expressions in a set. The sum_reduce directive computes the sum of the values of the expressions in a set.

max-reduce-directive ::= .max_reduce symbol , symbol , expression
sum-reduce-directive ::= .sum_reduce symbol , symbol , expression

The first symbol is defined using the value computed by the directive. The second symbol is the key symbol identifying the set of expressions (see add_to_set). The expression specifies the initial value for the reduction operation.

align

The align directive pads the active location counter section to the specified storage boundary. Its syntax is:

align-directive ::= .align expression

The expression must be a constant expression; its value must be a power of 2. This value specifies the alignment required in bytes.

ascii, asciiz

The ascii directive assembles each string into consecutive addresses. The asciiz directive is the same, except that each string is followed by a null byte.

ascii-directive ::= .ascii string-list
| .asciiz string-list
string-list ::= string-list , string
| .asciiz string

byte, short, int, long, word

These directives emit, for each expression, a number that at run-time is the value of that expression. The byte order is determined by the endianness of the target architecture. The size of numbers emitted with the word directive is determined by the size of the natural word on the target architecture. The size of the numbers emitted using the other directives are determined by the sizes of corresponding types in the ABI.

value-directive ::= value-size exp-list
value-size ::= .byte
| .short
| .int
| .long
| .word
exp-list ::= exp-list , expression
| expression

file

The file directive has two forms.

file-directive ::= .file string
| .file constant string

When used with one argument, the file directive creates an ELF symbol table entry with type STT_FILE and the specified string value. This entry is guaranteed to be the first entry in the symbol table.

When used with two arguments the file directive adds an entry to the DWARF 3 .debug_line file names table. The first argument is a unique positive integer to use as the index of the entry in the table. The second argument is the name of the file.

loc

The .loc directive adds a row to the DWARF 3 .debug_line line number matrix.

loc-directive ::= constant constant constantopt
| constant constant constant ⟨loc-option⟩*
loc-option ::= basic_block
| prologue_end
| epilogue_begin
| is_stmt constant
| isa constant

The address register is set to active location counter. The first two arguments set the file and line registers respectively. The optional third argument sets the column register. Additional arguments set further registers in the .debug_line state machine.

basic_block

Sets basic_block to true.

prologue_end

Sets prologue_end to true.

epilogue_begin

Sets epilogue_begin to true.

is_stmt

Sets is_stmt to the specified value, which must be 0 or 1.

isa

Sets isa to the specified value.

weak

The weak directive sets the weak attribute on the specified symbol.

weak-directive ::= .weak symbol

globl, global, extern, locl, local

The globl directive makes the specified symbols visible to other objects during linking. The extern directive specifies that the symbol is defined in another object. The locl directive specifies a symbol has local binding.

visibility ::= .globl
| .extern
| .locl
| .global
| .extern
| .local
vis-directive ::= visibility symbol
| visibility symbol , string

If the optional string is provided, an SHT_TYPEINFO entry is created in the ELF-extended type section which contains the symbol and an index into the string table whose entry contains the specified string. (If the string does not already exist in the string table, it is inserted.) The meaning of this string is determined by the ABI.

The global and local directives are synonyms for the globl and locl directives. They are provided for compatibility with other assemblers.

globalresource

globalresource-directive ::= .globalresource expression , string
| .globalresource expression , string , string

The globalresource directive causes the assembler to add information to the binary to indicate that there was a global port or clock declaration. The first argument is the resource ID of the port. The second argument is the name of the variable. The optional third argument is the tile the port was declared on. For example:

.globalresource 0x10200, p, tile[0]

specifies that the port p was declared on tile[0] and initialized with the resource ID 0x10200.

typestring

The typestring adds an SHT_TYPEINFO entry in the ELF-extended type section which contains the symbol and an index into the string table whose entry contains the specified string. (If the string does not already exist in the string table, it is inserted.) The meaning of this string is determined by the ABI.

typestring-directive ::= .typestring symbol , string

ident, core, corerev

Each of these directives creates an ELF note section named “.xmos_note.”

info-directive ::= .ident string
| .core string
| .corerev string

The contents of this section is a (name, type, value) triplet: the name is xmos; the type is either IDENT, CORE or COREREV; and the value is the specified string.

section, pushsection, popsection

The section directives change the current ELF section (see Sections and Relocations).

section-directive ::= sec-or-push name
| sec-or-push name , flags sec-typeopt
| .popsection
sec-or-push ::= .section
| .pushsection
flags ::= string
sec-type ::= type
| type , flag-args
type ::= @progbits
| @nobits
flag-args ::= string

The code following a section or pushsection directive is assembled and appended to the named section. The optional flags may contain any combination of the following characters.

a

section is allocatable

c

section is placed in the global constant pool

d

section is placed in the global data region

w

section is writable

x

section is executable

M

section is mergeable

S

section contains zero terminated strings

The optional type argument progbits specifies that the section contains data; nobits specifies that it does not.

If the M symbol is specified as a flag, a type argument must be specified and an integer must be provided as a flag-specific argument. The flag-specific argument represents the entity size of data entries in the section. For example:

.section .cp.const4, "M", @progbits, 4

Sections with the M flag but not S flag must contain fixed-size constants, each flag-args bytes long. Sections with both the M and S flags must contain zero-terminated strings, each character flag-args bytes long. The linker may remove duplicates within sections with the same name, entity size and flags.

Each section with the same name must have the same type and flags. The section directive replaces the current section with the named section. The pushsection directive pushes the current section onto the top of a section stack and then replaces the current section with the named section. The popsection directive replaces the current section with the section on top of the section stack and then pops this section from the stack.

text

The text directive changes the current ELF section to the .text section. The section type and attributes are determined by the ABI.

text-directive ::= .text

set, linkset

A symbol is assigned a value using the set or linkset directive.

set-directive ::= set-type symbol , expression
set-type ::= .set
| .linkset

The set directive defines the named symbol with the value of the expression. The expression must be either a constant or a symbol: if the expression is a constant, the symbol is defined in the absolute section; if the expression is a symbol, the defined symbol inherits its section information and other attributes from this symbol.

The linkset directive is the same, except that the expression is not evaluated; instead one or more SHT_EXPR entries are created in the ELF-extended expression section which together form a tree representation of the expression.

Any symbol used in the assembly code may be a target of an SHT_EXPR entry, in which case its value is computed by the linker by evaluating the expression once values for all other symbols in the expression are known. This may happen at any incremental link stage; once the value is known, it is assigned to the symbol as with set and the expression entry is eliminated from the linked object.

cc_top, cc_bottom

The cc_top and cc_bottom directives are used to mark the beginning and end of elimination blocks.

cc-top-directive ::= .cc_top name , predicate
| .cc_top name
cc-directive ::= cc-top-directive
| .cc_bottom name
name ::= symbol
predicate ::= symbol

cc_top and cc_bottom directives with the same name refer to the same elimination block. An elimination block must have precisely one cc_top directive and one cc_bottom directive. The top and bottom of an elimination block must be in the same section. The elimination block consists of the data and labels in this section between the cc_top and cc_bottom directives. Elimination blocks must be disjoint; it is illegal for elimination blocks to overlap.

An elimination block is retained in final executable if one of the following is true:

  • A label inside the elimination block is referenced from a location outside an elimination block.
  • A label inside the elimination block is referenced from an elimination block which is not eliminated
  • The predicate symbol is defined outside an elimination block or is contained in an elimination block which is not eliminated.

If none of these conditions are true the elimination block is removed from the final executable.

scheduling

The scheduling directive enables or disables instruction scheduling. When scheduling is enabled, the assembler may reorder instructions to minimize the number of FNOPs. The default scheduling mode is determined by the command-line option -fschedule.

scheduling-directive ::= .scheduling scheduling-mode
scheduling-mode ::= on
| off
| default

issue_mode

The issue_mode directive changes the current issue mode assumed by the assembler. See Instructions for details of how the issue mode affects how instructions are assembled.

issue-mode-directive ::= issue_mode issue-mode
issue-mode ::= single
| dual

syntax

The syntax directive changes the current syntax mode. See Instructions for details of how assembly instructions are specified in each mode.

syntax-directive ::= .syntax syntax
syntax ::= default
| architectural

assert

assert-directive ::= .assert constant , symbol , string

The assert directive requires an assertion to be tested prior to generating an executable object: the assertion fails if the symbol has a non-zero value. If the constant is 0, a failure should be reported as a warning; if the constant is 1, a failure should be reported as an error. The string is a message for an assembler or linker to emit on failure.

Overlay Directives

The overlay directives control how code and data is partitioned into overlays that are loaded on demand at runtime.

overlay-directive ::= .overlay_reference symbol , symbol
| .overlay_root symbol , symbol
| .overlay_root symbol
| .overlay_subgraph_conflict sym-list
sym-list ::= sym-list , symbol
| symbol
  • The overlay_root directive specifies that the first symbol should be treated as an overlay root. The optional second symbols specifies a overlay key symbol. If no overlay key symbol is explictly specified the overlay root symbol is used as the key symbol. Specifying the same overlay key symbol for multiple overlay roots forces the overlay roots into the same overlay.
  • The overlay_reference directive specifies that linker should assume that there is a reference from the first symbol to the second symbol when it partitions the program into overlays.
  • The overlay_subgraph_conflict directive specifies that linker should not place any code or data reachable from one the symbols into an overlay that is mapped an overlay region that contains another overlay containing code or data reachable from one of the other symbols.

Language Directives

The language directives create entries in the ELF-extended expression section; the encoding is determined by the ABI.

xc-directive ::= globdir symbol , string
| globdir symbol , symbol , range-args , string
| .globpassesref symbol , symbol , string
| .call symbol , symbol
| .par symbol , symbol , string
range-args ::= expression , expression
globdir ::= .globread
| .globwrite
| .parwrite
| .globpassesref

For each directive, the string is an error message for the assembler or linker to display on encountering an error attributed to the directive.

call

Both symbols must have function type. This directive sets the property that the first function may make a call to the second function.

par

Both symbols must have function type. This directive sets the property that the first function is invoked in parallel with the second function.

globread

The first symbol must have function type and the second directive must have object type. This directive sets the property that the function may read the object. When a range is specified, the first expression is the offset from the start of the variable in bytes of the address which is read and the second expression is the size of the read in bytes.

globwrite

The first symbol must have function type and the second directive must have object type. This directive sets the property that the function may write the object. When a range is specified, the first expression is the offset from the start of the variable in bytes of the address which is written and the second expression is the size of the write in bytes.

parwrite

The first symbol must have function type and the second directive must have object type. This directive set the property that the function is called in an expression which writes to the object where the order of evalulation of the write and the function call is undefined. When a range is specified, the first expression is the offset from the start of the variable in bytes of the address which is written and the second expression is the size of the write in bytes.

globpassesref

The first symbol must have function type and the second directive must have object type. This directive sets the property that the object may be passed by reference to the function.

XMOS Timing Analyzer Directives

The XMOS Timing Analyzer directives add timing metadata to ELF sections.

xta-directive ::= .xtabranch exp-listopt
| .xtaendpoint string , source-location
| .xtacall string , source-location
| .xtalabel string , source-location
| .xtathreadstart
| .xtathreadstop
| .xtaloop constant
| .xtacommand string , source-location
source-location ::= string , string , constant

The first string of a source location is the compilation directory. The second string is the path to the file. The path may be specified as either a relative path from the compilation directory or as an absolute path. The third argument is the line number.

  • xtabranch specifies a comma-separated list of locations that may be branched to from the current location.
  • xtaendpoint marks the current location as an endpoint with the specified label.
  • xtacall marks the current location as a function call with the specified label.
  • xtalabel marks the current location using the specified label.
  • xtathreadstart apecifies that a thread may be initialized to start executing at the current location.
  • xtathreadstop specifies that a thread executing the instruction at the current location will not execute any further instructions.
  • xtaloop specifies that the innermost loop containing the current location executes the specified number of times.
  • xtacommand specifies an XTA command to be executed when analyzing the executable.

uleb128, sleb128

The following directives emit, for each expression in the comma-separated list of expressions, a value that encodes either an unsigned or signed DWARF little-endian base 128 number.

leb-directive ::= .uleb128 exp-list
| .sleb128 exp-list

space, skip

The space directive emits a sequence of bytes, specified by the first expression, each with the fill value specified by the second expression. Both expressions must be constant expressions.

space-or-skip ::= .space
| .skip
space-directive ::= space-or-skip expression
| space-or-skip expression , expression

The skip directive is a synonym for the space directive. It is provided for compatibility with other assemblers.

type

The type directive specifies the type of a symbol to be either a function symbol or an object symbol.

type-directive ::= .type symbol , symbol-type
symbol-type ::= @function
| @object

size

The size directive specifies the size associated with a symbol.

size-directive ::= .size symbol , expression

jmptable, jmptable32

The jmptable and jmptable32 directives generate a table of unconditional branch instructions. The target of each branch instruction is the next label in the list. The size of the each branch instruction is 16 bits for the jmptable directive and 32 bits for the jmptable32 directive.

jmptable-directive ::= .jmptable jmptable-listopt
| .jmptable32 jmptable-listopt
jmptable-list ::= symbol
| jmptable-list symbol

Each symbol must be a label. A maximum of 32 labels maybe specified. If the unconditional branch distance does not fit into a 16-bit branch instruction, a branch is made to a trampoline at the end of the table, which performs the branch to the target label.

Instructions

Assembly instructions are normally inserted into an ELF text section. The syntax of an instruction is:

instruction ::= mnemonic instruction-argsopt
instruction-args ::= instruction-args , instruction-arg
| instruction-arg
instruction-arg ::= symbol [ expression ]
| symbol [ expression ] : symbol
| expression

To target the dual issue execution mode of xCORE-200 devices, instructions may be put in bundles:

separator ::= newline
| ;
instruction-bundle ::= { ⟨separator⟩* bundle-contents ⟨separator⟩* }
bundle-contents ::= instruction ⟨separator⟩+ instruction
| instruction

The current issue mode, as specifed by the issue_mode directive (see issue_mode), affects how the assembler assembles instructions. Initially the current issue mode is single and instruction bundles cannot be used. If the current issue mode is changed to dual then:

  • Instruction bundles can be specified.
  • 16-bit instructions not in an instruction bundle are implicitly placed in an instruction bundle alongside a NOP instruction.
  • The encoding of some operands may change. For example the assembler applies a different scaling factor to the immediate operand of relative branch instructions to match the different scaling factor that the processor uses at runtime when the instruction is executed in dual issue mode.

The order in which instructions are listed in an instruction bundle is not significant. The assembler may reorder the instructions in the bundle to satisfy architectural constraints.

The assembly instructions are summarized below using the default assembly syntax. The architecture manual documents the architectural syntax of the instructions. The syntax directive is used to switch the syntax mode.

The following notation is used:

bitp

one of: 1, 2, 3, 4, 5, 6, 7, 8, 16, 24 and 32

b

register used as a base address

c

register used as a conditional operand

d, e

register used as a destination operand

i

register used as a index operand

r

register used as a resource identifier

s

register used as a source operand

t

register used as a thread identifier

us

small unsigned constant in the range 0...11

ux

unsigned constant in the range 0...(2x-1)

v, w, x, y

registers used for two or more source operands

A register is one of: r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, sp, dp, cp and lr. The instruction determines which of these registers are permitted.

Where there is choice of instruction formats, the assembler chooses the format with the smallest size. To force a specific format, specify a mnemonic of the form INSTRUCTION_format where the instruction and format names are as described in the architecture manual. For example the LDWCP_ru6 mnemonic specifies the ru6 format of the LDWCP instruction.

Data Access

Mnemonic

Operands

Meaning

ld16s

d, b[i]

Load signed 16 bits

ld8u

d, b[i]

Load unsigned 8 bits

lda16

d, b[i]

Add to 16-bit address

lda16

d, b[-i]

Subtract from 16-bit address

ldap

r11, u20

Load pc-relative address

ldap

r11, -u20

Load pc-relative address

ldaw

d, b[i]

Add to a word address

ldaw

d, b[-i]

Subtract from a word address

ldaw

d, b[us]

Add to a word address immediate

ldaw

d, b[-us]

Subtract from a word address immediate

ldaw

r11, cp[u16]

Load address of word in constant pool

ldaw

d, dp[u16]

Load address of word in data pool

ldaw

d, sp[u16]

Load address of word on stack

ldd

e, d, b[i]

Load double word (xCORE-200 only)

ldd

e, d, b[us]

Load double word immediate (xCORE-200 only)

ldd

e, d, sp[us]

Load double from the stack (xCORE-200 only)

ldw

et, sp[4]

Load ET from the stack

ldw

sed, sp[3]

Load SED from the stack

ldw

spc, sp[1]

Load SPC from the stack

ldw

ssr, sp[2]

Load SSR from the stack

ldw

d, b[i]

Load word

ldw

d, b[us]

Load word immediate

ldw

d, cp[u16]

Load word from constant pool

ldw

r11, cp[u20]

Load word from constant pool

ldw

d, dp[u16]

Load word from data pool

ldw

d, sp[u16]

Load word from stack

set

cp, s

Set constant pool

set

dp, s

Set data pointer

set

sp, s

Set the stack pointer

st16

s, b[i]

16-bit store

st8

s, b[i]

8-bit store

std

e, d, b[i]

Store double word (xCORE-200 only)

std

e, d, b[us]

Store double word immediate (xCORE-200 only)

std

y, x, sp[us]

Store double word on the stack (xCORE-200 only)

stw

sed, sp[3]

Store SED on the stack

stw

et, sp[4]

Store ET on the stack

stw

spc, sp[1]

Store SPC on the stack

stw

ssr, sp[2]

Store SSR on the stack

stw

s, b[i]

Store word

stw

s, b[us]

Store word immediate

stw

s, dp[u16]

Store word in data pool

stw

s, sp[u16]

Store word on stack

Branching, Jumping and Calling

Mnemonic

Operands

Meaning

bau

s

Branch absolute unconditional

bf

c, u16

Branch relative if false

bf

c, -u16

Branch relative if false

bl

u20

Branch and link relative

bl

-u20

Branch and link relative

bla

s

Branch and link absolute via register

bla

cp[u20]

Branch and link absolute via CP

blat

u16

Branch and link absolute via table

bru

s

Branch relative unconditional via register

bt

c, u16

Branch relative if true

bt

c, -u16

Branch relative if true

bu

u16

Branch relative unconditional

bu

-u16

Branch relative unconditional

dualentsp

u16

Adjust stack, save link register and enable dual issue (xCORE-200 only)

entsp

u16

Adjust stack and save link register and enable single issue

extdp

u16

Extend data pointer

extsp

u16

Extend stack pointer

retsp

u16

Return

Data Manipulation

Mnemonic

Operands

Meaning

add

d, x, y

Add

add

d, x, us

Add immediate

and

d, x, y

Bitwise and

andnot

d, s

And not

ashr

d, x, y

Arithmetic shift right

ashr

d, x, bitp

Arithmetic shift right immediate

bitrev

d, s

Bit reverse

byterev

d, s

Byte reverse

clz

d, s

Count leading zeros

crc32

d, r, p

Word CRC

crc32_inc

d, e, x, y, bitp

Word CRC with address increment (xCORE-200 only)

crc8

r, o, d, p

8-step CRC

crcn

d, x, p, n

Variable step CRC (xCORE-200 only)

divs

d, x, y

Signed division

divu

d, x, y

Unsigned division

eq

c, x, y

Equal

eq

c, x, us

Equal immediate

ladd

e, d, x, y, v

Long unsigned add with carry

ldc

d, u16

Load constant

ldivu

d, e, v, x, y

Long unsigned divide

lextract

d, x, y, u, bitp

Bitfield extraction from register pair (xCORE-200 only)

linsert

d, e, x, y, bitp

Inserts a bitfield into a pair of registers (xCORE-200 only)

lmul

d, e, x, y, v, w

Long multiply

lsats

d, x, y

Saturate signed (xCORE-200 only)

lss

c, x, y

Less than signed

lsu

c, x, y

Less than unsigned

lsub

e, d, x, y, v

Long unsigned subtract

maccs

d, e, x, y

Mulitply and accumulate signed

maccu

d, e, x, y

Multiply and accumulate unsigned

mkmsk

d, s

Make mask

mkmsk

d, bitp

Make mask immediate

mul

d, x, y

Multiply

neg

d, s

Two’s complement negate

not

d, s

Bitwise not

or

d, x, y

Bitwise or

rems

d, x, y

Signed remainder

remu

d, x, y

Unsigned remainder

sext

d, s

Sign extend

sext

d, bitp

Sign extend immediate

shl

d, x, y

Shift left

shl

d, x, bitp

Shift left immediate

shr

d, x, y

Shift right

shr

d, x, bitp

Shift right immediate

sub

d, x, y

Subtract

sub

d, x, us

Subtract immediate

unzip

d, e, x

Unzips a pair of registers (xCORE-200 only)

xor

d, x, y

Bitwise exclusive or

xor4

d, e, x, y, v

Bitwise exclusive or of four words (xCORE-200 only)

zext

d, s

Zero extend

zext

s, bitp

Zero extend immediate

zip

d, e, x

Zips together a pair of registers (xCORE-200 only)

Concurrency and Thread Synchronization

Mnemonic

Operands

Meaning

freet

 

Free unsynchronized thread

get

r11, id

Get thread ID

getst

d, res[r]

Get synchronized thread

mjoin

res[r]

Master synchronize and join

msync

res[r]

Master synchronize

ssync

 

Slave synchronize

init

t[r]:cp, s

Initialize thread’s CP

init

t[r]:dp, s

Initialize thread’s DP

init

t[r]:lr, s

Initialize thread’s LR

init

t[r]:pc, s

Initialize thread’s PC

init

t[r]:sp, s

Initialize thread’s SP

set

t[r]:d, s

Set register in thread

start

t[r]

Start thread

tsetmr

d, s

Set register in master thread

Communication

Mnemonic

Operands

Meaning

chkct

res[r], s

Test for control token

chkct

res[r], us

Test for control token immediate

getn

d, res[r]

Get network

in

d, res[r]

Input data

inct

d, res[r]

Input control token

int

d, res[r]

Input token of data

out

res[r], s

Output data

outct

res[r], s

Output control token

outct

res[r], us

Output control token immediate

outt

res[r], s

Output token of data

setn

res[r], s

Set network

testlcl

d, res[r]

Test local

testct

d, res[r]

Test for control token

testwct

d, res[r]

Test for position of control token

Resource Operations

Mnemonic

Operands

Meaning

clrpt

res[r]

Clear port time

elate

s

Throw exception if too late (xCORE-200 only)

endin

d, res[r]

End a current input

freer

res[r]

Free a resource

getd

d, res[r]

Get resource data

getr

d, us

Allocate resource

gettime

d

Get the reference time (xCORE-200 only)

getts

d, res[r]

Get port timestamp

in

d, res[r]

Input data

inpw

d, res[r], bitp

Input a part word

inshr

d, res[r]

Input and shift right

out

res[r], s

Output data

outpw

res[r], s, bitp

Output a part word

outpw

res[r], s, w

Output a part word immediate (xCORE-200 only)

outshr

res[r], s

Output data and shift

peek

d, res[r]

Peek at port data

setc

res[r], s

Set resource control bits

setc

res[r], u16

Set resource control bits immediate

setclk

res[r], s

Set clock for a resource

setd

res[r], s

Set data

setev

res[r], r11

Set environment vector

setpsc

res[r], s

Set the port shift count

setpt

res[r], s

Set the port time

setrdy

res[r], s

Set ready input for a port

settw

res[r], s

Set transfer width for a port

setv

res[r], r11

Set event vector

syncr

res[r]

Synchronize a resource

Event Handling

Mnemonic

Operands

Meaning

clre

 

Clear all events

clrsr

u16

Clear bits in SR

edu

res[r]

Disable events

eef

d, res[r]

Enable events if false

eet

d, res[r]

Enable events if true

eeu

res[r]

Enable events

getsr

r11, u16

Get bits from SR

setsr

u16

Set bits in SR

waitef

c

Wait for event if false

waitet

c

Wait for event if true

waiteu

 

Wait for event

Interrupts, Exceptions and Kernel Calls

Mnemonic

Operands

Meaning

clrsr

u16

Clear bits in SR

ecallf

c

Raise exception if false

ecallt

c

Raise exception if true

get

r11, ed

Get ED into r11

get

r11, et

Get ET into r11

get

r11, kep

Get the kernel entry point

get

r11, ksp

Get the kernel stack pointer

getsr

r11, u16

Get bits from SR

kcall

s

Kernel call

kcall

u16

Kernel call immediate

kentsp

u16

Switch to kernel stack

krestsp

u16

Restore stack pointer from kernel stack

kret

 

Kernel return

set

kep, r11

Set the kernel entry point

setsr

u16

Set bits in SR

Debugging

Mnemonic

Operands

Meaning

dcall

 

Cause a debug interrupt

dentsp

 

Save and modify stack pointer for debug

dgetreg

s

Debug read of another thread’s register

drestsp

 

Restore non debug stack pointer

dret

 

Return from debug interrupt

get

d, ps[r]

Get processor state

set

ps[r], s

Set processor state

Pseudo Instructions

In the default syntax mode, the assembler supports a small set of pseudo instructions. These instructions do not exist on the processor, but are translated by the assembler into xCORE instructions.

Mnemonic

Operands

Definition

mov

d, s

add d, s, 0

nop

 

r0, r0, 0

Assembly Program

An assembly program consists of a sequence of statements.

program ::= ⟨statement⟩*
statement ::= label-listopt dir-or-instopt separator
label-list ::= label
| label-list label
dir-or-inst ::= directive
| instruction
| instruction-bundle
directive ::= align-directive
| ascii-directive
| value-directive
| file-directive
| loc-directive
| weak-directive
| vis-directive
| text-directive
| set-directive
| cc-directive
| scheduling-directive
| syntax-directive
| assert-directive
| xc-directive
| xta-directive
| space-directive
| type-directive
| size-directive
| jmptable-directive
| globalresource-directive